!217 Serving, ci warning clear

From: @xu-yfei
Reviewed-by: @zhoufeng54,@jjfeing
Signed-off-by: @jjfeing

CMakeLists.txt

@@ -1,22 +1,25 @@
 cmake_minimum_required(VERSION 3.14.1)
-project (MindSpore_Serving)
+project(MindSpore_Serving)
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.3.0)
-    message(FATAL_ERROR "GCC vesion ${CMAKE_CXX_COMPILER_VERSION} must not be less than 7.3.0")
-endif ()
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.3.0)
+    message(FATAL_ERROR "GCC version ${CMAKE_CXX_COMPILER_VERSION} must not be less than 7.3.0")
+endif()
 
 include(${CMAKE_SOURCE_DIR}/cmake/options.cmake)  # set compile options
 include(${CMAKE_SOURCE_DIR}/cmake/check_requirements.cmake) # check require party, like OpenSSL
-set(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O2 -Wl,--allow-shlib-undefined -DHALF_ENABLE_CPP11_USER_LITERALS=0 -D_FORTIFY_SOURCE=2")
-if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
+set(CMAKE_CXX_FLAGS_RELEASE "$ENV{CXXFLAGS} -O2 -Wl,--allow-shlib-undefined -DHALF_ENABLE_CPP11_USER_LITERALS=0 \
+    -D_FORTIFY_SOURCE=2")
+if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
     add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0)
-endif ()
+endif()
 
-if (ENABLE_PYTHON)
+if(ENABLE_PYTHON)
     add_compile_definitions(ENABLE_PYTHON)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -g2 -ggdb -fno-inline-functions -fno-omit-frame-pointer -Wl,--allow-shlib-undefined -D_LIBCPP_INLINE_VISIBILITY='' -D_LIBCPP_DISABLE_EXTERN_TEMPLATE=1 -DHALF_ENABLE_CPP11_USER_LITERALS=0 -D_FORTIFY_SOURCE=2 -Wno-cpp")
+set(CMAKE_CXX_FLAGS_DEBUG "$ENV{CXXFLAGS} -O0 -g2 -ggdb -fno-inline-functions -fno-omit-frame-pointer \
+    -Wl,--allow-shlib-undefined -D_LIBCPP_INLINE_VISIBILITY='' -D_LIBCPP_DISABLE_EXTERN_TEMPLATE=1 \
+    -DHALF_ENABLE_CPP11_USER_LITERALS=0 -D_FORTIFY_SOURCE=2 -Wno-cpp")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -I/usr/local/include -std=c++17 -Werror -Wall -fPIC")
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
@@ -34,13 +37,13 @@ find_package(Python3 3.7 COMPONENTS Interpreter Development)
 if(Python3_FOUND)
     set(PYTHON_INCLUDE_DIRS "${Python3_INCLUDE_DIRS}")
     set(PYTHON_LIBRARIES "${Python3_LIBRARIES}")
-    if (WIN32)
-        if (Python3_DIR)
+    if(WIN32)
+        if(Python3_DIR)
             message("Python3_DIR set already: " ${Python3_DIR})
         else()
             string(LENGTH ${PYTHON_LIBRARIES} PYTHON_LIBRARIES_LEN)
             string(LENGTH "libpythonxx.a" Python3_NAME_LEN)
-            math(EXPR Python3_DIR_LEN  ${PYTHON_LIBRARIES_LEN}-${Python3_NAME_LEN})
+            math(EXPR Python3_DIR_LEN ${PYTHON_LIBRARIES_LEN}-${Python3_NAME_LEN})
             string(SUBSTRING ${Python3_LIBRARIES} 0 ${Python3_DIR_LEN} Python3_DIR)
             message("Python3_DIR: " ${Python3_DIR})
         endif()
@@ -63,8 +66,6 @@ if(MS_WHL_LIB_PATH OR MS_BACKEND)
     include(cmake/package.cmake)
 endif()
 
-if (ENABLE_TESTCASES)
+if(ENABLE_TESTCASES)
     add_subdirectory(tests)
 endif()
-
-

cmake/dependency_securec.cmake

@@ -4,17 +4,17 @@
 # SECUREC_LIBRARY
 #
 
-if (NOT TARGET securec)
-  set(_ms_tmp_CMAKE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
-  set(_ms_tmp_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
+if(NOT TARGET securec)
+    set(_ms_tmp_CMAKE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE})
+    set(_ms_tmp_CMAKE_C_FLAGS ${CMAKE_C_FLAGS})
 
-  set(CMAKE_C_FLAGS "${SECURE_CXX_FLAGS}")
-  if (CMAKE_SYSTEM_NAME MATCHES "Windows")
-    add_compile_definitions(SECUREC_ONLY_DECLARE_MEMSET)
-  endif()
-  add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../third_party/securec ${CMAKE_BINARY_DIR}/securec)
-  set(CMAKE_POSITION_INDEPENDENT_CODE ${_ms_tmp_CMAKE_POSITION_INDEPENDENT_CODE})
-  set(CMAKE_C_FLAGS ${_ms_tmp_CMAKE_C_FLAGS})
+    set(CMAKE_C_FLAGS "${SECURE_CXX_FLAGS}")
+    if(CMAKE_SYSTEM_NAME MATCHES "Windows")
+        add_compile_definitions(SECUREC_ONLY_DECLARE_MEMSET)
+    endif()
+    add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/../third_party/securec ${CMAKE_BINARY_DIR}/securec)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ${_ms_tmp_CMAKE_POSITION_INDEPENDENT_CODE})
+    set(CMAKE_C_FLAGS ${_ms_tmp_CMAKE_C_FLAGS})
 endif()
 
 include_directories(${CMAKE_CURRENT_LIST_DIR}/../third_party/securec/include)

cmake/dependency_utils.cmake

@@ -2,24 +2,25 @@
 #
 
 function(find_python_package out_inc out_lib)
-  # Use PYTHON_EXECUTABLE if it is defined, otherwise default to python
-  if ("${PYTHON_EXECUTABLE}" STREQUAL "")
-    set(PYTHON_EXECUTABLE "python3")
-  else()
-    set(PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}")
-  endif()
+    # Use PYTHON_EXECUTABLE if it is defined, otherwise default to python
+    if("${PYTHON_EXECUTABLE}" STREQUAL "")
+        set(PYTHON_EXECUTABLE "python3")
+    else()
+        set(PYTHON_EXECUTABLE "${PYTHON_EXECUTABLE}")
+    endif()
 
-  execute_process(
-          COMMAND "${PYTHON_EXECUTABLE}" -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())"
-          RESULT_VARIABLE result
-          OUTPUT_VARIABLE inc)
-  string(STRIP "${inc}" inc)
-  set(${out_inc} ${inc} PARENT_SCOPE)
-  
-  execute_process(
-          COMMAND "${PYTHON_EXECUTABLE}" -c "import distutils.sysconfig as sysconfig; import os; print(os.path.join(sysconfig.get_config_var('LIBDIR'), sysconfig.get_config_var('LDLIBRARY')))"
-          RESULT_VARIABLE result
-          OUTPUT_VARIABLE lib)
-  string(STRIP "${lib}" lib)
-  set(${out_lib} ${lib} PARENT_SCOPE)
+    execute_process(
+            COMMAND "${PYTHON_EXECUTABLE}" -c "from distutils.sysconfig import get_python_inc; print(get_python_inc())"
+            RESULT_VARIABLE result
+            OUTPUT_VARIABLE inc)
+    string(STRIP "${inc}" inc)
+    set(${out_inc} ${inc} PARENT_SCOPE)
+
+    execute_process(
+            COMMAND "${PYTHON_EXECUTABLE}" -c "import distutils.sysconfig as sysconfig; import os; \
+                    print(os.path.join(sysconfig.get_config_var('LIBDIR'), sysconfig.get_config_var('LDLIBRARY')))"
+            RESULT_VARIABLE result
+            OUTPUT_VARIABLE lib)
+    string(STRIP "${lib}" lib)
+    set(${out_lib} ${lib} PARENT_SCOPE)
 endfunction()

cmake/external_libs/gtest.cmake

@@ -9,5 +9,7 @@ mindspore_add_pkg(gtest
         -DCMAKE_MACOSX_RPATH=TRUE -Dgtest_disable_pthreads=ON)
 include_directories(${gtest_INC})
 add_library(mindspore_serving::gtest ALIAS gtest::gtest)
-file(COPY ${gtest_LIBPATH}/libgtest${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION ${CMAKE_BINARY_DIR}/googletest/googlemock/gtest)
-file(COPY ${gtest_LIBPATH}/libgtest_main${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION ${CMAKE_BINARY_DIR}/googletest/googlemock/gtest)
+file(COPY ${gtest_LIBPATH}/libgtest${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION
+        ${CMAKE_BINARY_DIR}/googletest/googlemock/gtest)
+file(COPY ${gtest_LIBPATH}/libgtest_main${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION
+        ${CMAKE_BINARY_DIR}/googletest/googlemock/gtest)

cmake/options.cmake

@@ -10,47 +10,48 @@ if(MS_WHL_LIB_PATH)
     message("MindSpore whl lib path:" ${MS_WHL_LIB_PATH})
 elseif(MS_BACKEND)
     message("MindSpore backend method:" ${MS_BACKEND})
-elseif (RUN_TESTCASES)
+elseif(RUN_TESTCASES)
     message("MindSpore Serving Compile UT:" ${RUN_TESTCASES})
-elseif ()
+elseif()
     message(FATAL_ERROR "Please confirm how to use MindSpore.")
 endif()
 
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND Linux)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND Linux)
     set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fstack-protector-all -Wl,-z,relro,-z,now,-z,noexecstack")
 endif()
 
-if (ENABLE_COVERAGE)
+if(ENABLE_COVERAGE)
     set(COVERAGE_COMPILER_FLAGS "-g --coverage -fprofile-arcs -ftest-coverage")
     set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}")
 endif()
 
-if (ENABLE_ASAN)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fsanitize=address -fsanitize-recover=address -fno-omit-frame-pointer -fsanitize=undefined")
+if(ENABLE_ASAN)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fsanitize=address -fsanitize-recover=address \
+                              -fno-omit-frame-pointer -fsanitize=undefined")
     else()
-        set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -static-libsan -fsanitize=undefined")
+        set(OPTION_CXX_FLAGS "${OPTION_CXX_FLAGS} -fsanitize=address -fno-omit-frame-pointer -static-libsan \
+                              -fsanitize=undefined")
     endif()
 endif()
 
-if (DEBUG_MODE)
+if(DEBUG_MODE)
     set(CMAKE_BUILD_TYPE "Debug")
     add_compile_definitions(MEM_REUSE_DEBUG)
 else()
     set(CMAKE_BUILD_TYPE "Release")
 endif()
 
-if ((CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64") OR (CMAKE_BUILD_TYPE STREQUAL Release))
+if((CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64") OR (CMAKE_BUILD_TYPE STREQUAL Release))
     set(PYBIND11_LTO_CXX_FLAGS FALSE)
 endif()
 
-if (NOT BUILD_PATH)
+if(NOT BUILD_PATH)
     set(BUILD_PATH "${CMAKE_SOURCE_DIR}/build")
 endif()
 
-if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
+if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
     set(MS_BUILD_GRPC ON)
 endif()
 
 add_compile_definitions(USE_GLOG)
-

cmake/package.cmake

@@ -39,20 +39,20 @@ install(
 # set python files
 file(GLOB MS_PY_LIST ${CMAKE_SOURCE_DIR}/mindspore_serving/*.py)
 install(
-    FILES ${MS_PY_LIST}
-    DESTINATION ${INSTALL_PY_DIR}
-    COMPONENT mindspore_serving
+        FILES ${MS_PY_LIST}
+        DESTINATION ${INSTALL_PY_DIR}
+        COMPONENT mindspore_serving
 )
 
 install(
-    TARGETS _mindspore_serving
-    DESTINATION ${INSTALL_BASE_DIR}
-    COMPONENT mindspore_serving
+        TARGETS _mindspore_serving
+        DESTINATION ${INSTALL_BASE_DIR}
+        COMPONENT mindspore_serving
 )
 install(
-    TARGETS serving_common
-    DESTINATION ${INSTALL_LIB_DIR}
-    COMPONENT mindspore_serving
+        TARGETS serving_common
+        DESTINATION ${INSTALL_LIB_DIR}
+        COMPONENT mindspore_serving
 )
 install(
         TARGETS serving_ascend
@@ -60,17 +60,17 @@ install(
         COMPONENT mindspore_serving
 )
 install(
-    DIRECTORY
-    ${CMAKE_SOURCE_DIR}/mindspore_serving/master
-    ${CMAKE_SOURCE_DIR}/mindspore_serving/worker
-    ${CMAKE_SOURCE_DIR}/mindspore_serving/common
-    ${CMAKE_SOURCE_DIR}/mindspore_serving/client
-    DESTINATION ${INSTALL_PY_DIR}
-    COMPONENT mindspore_serving
+        DIRECTORY
+        ${CMAKE_SOURCE_DIR}/mindspore_serving/master
+        ${CMAKE_SOURCE_DIR}/mindspore_serving/worker
+        ${CMAKE_SOURCE_DIR}/mindspore_serving/common
+        ${CMAKE_SOURCE_DIR}/mindspore_serving/client
+        DESTINATION ${INSTALL_PY_DIR}
+        COMPONENT mindspore_serving
 )
 install(
-    FILES ${CMAKE_SOURCE_DIR}/build/mindspore_serving/mindspore_serving/mindspore_serving/proto/ms_service_pb2.py
-          ${CMAKE_SOURCE_DIR}/build/mindspore_serving/mindspore_serving/mindspore_serving/proto/ms_service_pb2_grpc.py
-    DESTINATION ${INSTALL_PY_DIR}/proto
-    COMPONENT mindspore_serving
+        FILES ${CMAKE_SOURCE_DIR}/build/mindspore_serving/mindspore_serving/mindspore_serving/proto/ms_service_pb2.py
+        ${CMAKE_SOURCE_DIR}/build/mindspore_serving/mindspore_serving/mindspore_serving/proto/ms_service_pb2_grpc.py
+        DESTINATION ${INSTALL_PY_DIR}/proto
+        COMPONENT mindspore_serving
 )

cmake/utils.cmake

@@ -16,45 +16,45 @@ function(mindspore_add_submodule_obj des_submodule_objs sub_dir submodule_name_o
 
 endfunction()
 
-if (DEFINED ENV{MSLIBS_CACHE_PATH})
-    set(_MS_LIB_CACHE  $ENV{MSLIBS_CACHE_PATH})
+if(DEFINED ENV{MSLIBS_CACHE_PATH})
+    set(_MS_LIB_CACHE $ENV{MSLIBS_CACHE_PATH})
 else()
     set(_MS_LIB_CACHE ${CMAKE_BINARY_DIR}/.mslib)
-endif ()
+endif()
 message("MS LIBS CACHE PATH:  ${_MS_LIB_CACHE}")
 
-if (NOT EXISTS ${_MS_LIB_CACHE})
+if(NOT EXISTS ${_MS_LIB_CACHE})
     file(MAKE_DIRECTORY ${_MS_LIB_CACHE})
-endif ()
+endif()
 
-if (DEFINED ENV{MSLIBS_SERVER})  # export MSLIBS_SERVER=49.4.0.74
-    set(LOCAL_LIBS_SERVER  $ENV{MSLIBS_SERVER})
+if(DEFINED ENV{MSLIBS_SERVER})  # export MSLIBS_SERVER=49.4.0.74
+    set(LOCAL_LIBS_SERVER $ENV{MSLIBS_SERVER})
     message("LOCAL_LIBS_SERVER:  ${LOCAL_LIBS_SERVER}")
-endif ()
+endif()
 
 include(ProcessorCount) # 确定处理器/核的数量并将值保存在${var}中
 ProcessorCount(N)
-if (JOBS)
+if(JOBS)
     set(THNUM ${JOBS})
 else()
     set(JOBS 8)
-    if (${JOBS} GREATER ${N})
+    if(${JOBS} GREATER ${N})
         set(THNUM ${N})
     else()
         set(THNUM ${JOBS})
     endif()
-endif ()
+endif()
 message("set make thread num: ${THNUM}")
 
 if(LOCAL_LIBS_SERVER)
-    if (NOT ENV{no_proxy})
+    if(NOT ENV{no_proxy})
         set(ENV{no_proxy} "${LOCAL_LIBS_SERVER}")
     else()
         string(FIND $ENV{no_proxy} ${LOCAL_LIBS_SERVER} IP_POS)
-        if (${IP_POS} EQUAL -1)
+        if(${IP_POS} EQUAL -1)
             set(ENV{no_proxy} "$ENV{no_proxy},${LOCAL_LIBS_SERVER}")
-        endif ()
-    endif ()
+        endif()
+    endif()
 endif()
 
 function(__download_pkg pkg_name pkg_url pkg_md5)
@@ -66,9 +66,9 @@ function(__download_pkg pkg_name pkg_url pkg_md5)
 
     FetchContent_Declare(  # 获取项目。可以是一个URL也可以是一个Git仓库。
             ${pkg_name}
-            URL      ${pkg_url}
+            URL ${pkg_url}
             URL_HASH MD5=${pkg_md5}
-    )
+            )
     FetchContent_GetProperties(${pkg_name}) # 获取我们需要的变量MyName_*。
     message("download: ${${pkg_name}_SOURCE_DIR} , ${pkg_name} , ${pkg_url}")
     if(NOT ${pkg_name}_POPULATED)
@@ -84,14 +84,14 @@ function(__download_pkg_with_git pkg_name pkg_url pkg_git_commit pkg_md5)
         set(pkg_url "http://${LOCAL_LIBS_SERVER}:8081/libs/${pkg_name}/${pkg_git_commit}")
         FetchContent_Declare(
                 ${pkg_name}
-                URL      ${pkg_url}
+                URL ${pkg_url}
                 URL_HASH MD5=${pkg_md5}
-    )
+        )
     else()
-	FetchContent_Declare(
-            ${pkg_name}
-	    GIT_REPOSITORY      ${pkg_url}
-	    GIT_TAG             ${pkg_git_commit})
+        FetchContent_Declare(
+                ${pkg_name}
+                GIT_REPOSITORY ${pkg_url}
+                GIT_TAG ${pkg_git_commit})
     endif()
     FetchContent_GetProperties(${pkg_name})
     message("download: ${${pkg_name}_SOURCE_DIR} , ${pkg_name} , ${pkg_url}")
@@ -128,46 +128,46 @@ function(__find_pkg_then_add_target pkg_name pkg_exe lib_path)
     foreach(_LIB_NAME ${ARGN})
         set(_LIB_SEARCH_NAME ${_LIB_NAME})
         set(_LIB_TYPE SHARED)
-        if (${pkg_name}_USE_STATIC_LIBS)
+        if(${pkg_name}_USE_STATIC_LIBS)
             set(_LIB_SEARCH_NAME "${CMAKE_STATIC_LIBRARY_PREFIX}${_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}")
             set(_LIB_TYPE STATIC)
-        endif ()
+        endif()
         set(${_LIB_NAME}_LIB ${_LIB_NAME}_LIB-NOTFOUND)
         find_library(${_LIB_NAME}_LIB ${_LIB_SEARCH_NAME} PATHS ${${pkg_name}_BASE_DIR}/${lib_path} NO_DEFAULT_PATH)
-        if (NOT ${_LIB_NAME}_LIB AND BUILD_LITE AND PLATFORM_ARM)
+        if(NOT ${_LIB_NAME}_LIB AND BUILD_LITE AND PLATFORM_ARM)
             set(${_LIB_NAME}_LIB "${${pkg_name}_BASE_DIR}/${lib_path}/lib${_LIB_SEARCH_NAME}.so")
-        endif(NOT ${_LIB_NAME}_LIB AND BUILD_LITE AND PLATFORM_ARM)
+        endif()
         if(NOT ${_LIB_NAME}_LIB)
             return()
         endif()
 
         add_library(${pkg_name}::${_LIB_NAME} ${_LIB_TYPE} IMPORTED GLOBAL)
-        if (WIN32 AND ${_LIB_TYPE} STREQUAL "SHARED")
+        if(WIN32 AND ${_LIB_TYPE} STREQUAL "SHARED")
             set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES IMPORTED_IMPLIB_RELEASE ${${_LIB_NAME}_LIB})
         else()
             set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES IMPORTED_LOCATION ${${_LIB_NAME}_LIB})
         endif()
 
-        if (EXISTS ${${pkg_name}_BASE_DIR}/include)
-            set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES 
-                INTERFACE_INCLUDE_DIRECTORIES "${${pkg_name}_BASE_DIR}/include")
-        endif ()
+        if(EXISTS ${${pkg_name}_BASE_DIR}/include)
+            set_target_properties(${pkg_name}::${_LIB_NAME} PROPERTIES
+                    INTERFACE_INCLUDE_DIRECTORIES "${${pkg_name}_BASE_DIR}/include")
+        endif()
 
         list(APPEND ${pkg_name}_LIBS ${pkg_name}::${_LIB_NAME})
         message("found ${${_LIB_NAME}_LIB}")
-        STRING( REGEX REPLACE "(.+)/(.+)" "\\1" LIBPATH ${${_LIB_NAME}_LIB})
+        STRING(REGEX REPLACE "(.+)/(.+)" "\\1" LIBPATH ${${_LIB_NAME}_LIB})
         set(${pkg_name}_LIBPATH ${LIBPATH} CACHE STRING INTERNAL)
-    endforeach(_LIB_NAME)
+    endforeach()
 
     set(${pkg_name}_LIBS ${${pkg_name}_LIBS} PARENT_SCOPE)
 endfunction()
 
 function(__exec_cmd)
-    set(options )
+    set(options)
     set(oneValueArgs WORKING_DIRECTORY)
     set(multiValueArgs COMMAND)
 
-    cmake_parse_arguments(EXEC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
+    cmake_parse_arguments(EXEC "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     execute_process(COMMAND ${EXEC_COMMAND}
             WORKING_DIRECTORY ${EXEC_WORKING_DIRECTORY}
@@ -179,42 +179,43 @@ endfunction()
 
 function(__check_patches pkg_patches)
     # check patches
-    if (PKG_PATCHES)
+    if(PKG_PATCHES)
         file(TOUCH ${_MS_LIB_CACHE}/${pkg_name}_patch.md5)
         file(READ ${_MS_LIB_CACHE}/${pkg_name}_patch.md5 ${pkg_name}_PATCHES_MD5)
 
         message("patches md5:${${pkg_name}_PATCHES_MD5}")
 
-        set(${pkg_name}_PATCHES_NEW_MD5 )
+        set(${pkg_name}_PATCHES_NEW_MD5)
         foreach(_PATCH ${PKG_PATCHES})
             file(MD5 ${_PATCH} _PF_MD5)
             set(${pkg_name}_PATCHES_NEW_MD5 "${${pkg_name}_PATCHES_NEW_MD5},${_PF_MD5}")
-        endforeach(_PATCH)
+        endforeach()
 
-        if (NOT ${pkg_name}_PATCHES_MD5 STREQUAL ${pkg_name}_PATCHES_NEW_MD5)
+        if(NOT ${pkg_name}_PATCHES_MD5 STREQUAL ${pkg_name}_PATCHES_NEW_MD5)
             set(${pkg_name}_PATCHES ${PKG_PATCHES})
             file(REMOVE_RECURSE "${_MS_LIB_CACHE}/${pkg_name}-subbuild")
             file(WRITE ${_MS_LIB_CACHE}/${pkg_name}_patch.md5 ${${pkg_name}_PATCHES_NEW_MD5})
             message("patches changed : ${${pkg_name}_PATCHES_NEW_MD5}")
-        endif ()
-    endif ()
+        endif()
+    endif()
 endfunction()
 
 set(MS_FIND_NO_DEFAULT_PATH NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_SYSTEM_ENVIRONMENT_PATH
-                            NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
-                            NO_CMAKE_SYSTEM_PACKAGE_REGISTRY)
+        NO_CMAKE_BUILDS_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_SYSTEM_PATH
+        NO_CMAKE_SYSTEM_PACKAGE_REGISTRY)
 set(MS_FIND_NO_DEFAULT_PATH ${MS_FIND_NO_DEFAULT_PATH} PARENT_SCOPE)
-function(mindspore_add_pkg pkg_name )
+function(mindspore_add_pkg pkg_name)
 
     message("---------add pkg: " ${pkg_name} "---------")
-    set(options )
+    set(options)
     set(oneValueArgs URL MD5 GIT_REPOSITORY GIT_TAG VER EXE DIR HEAD_ONLY CMAKE_PATH RELEASE LIB_PATH CUSTOM_CMAKE)
-    set(multiValueArgs CMAKE_OPTION LIBS PRE_CONFIGURE_COMMAND CONFIGURE_COMMAND BUILD_OPTION INSTALL_INCS INSTALL_LIBS PATCHES SUBMODULES SOURCEMODULES ONLY_MAKE ONLY_MAKE_INCS ONLY_MAKE_LIBS)
-    cmake_parse_arguments(PKG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
+    set(multiValueArgs CMAKE_OPTION LIBS PRE_CONFIGURE_COMMAND CONFIGURE_COMMAND BUILD_OPTION INSTALL_INCS INSTALL_LIBS
+            PATCHES SUBMODULES SOURCEMODULES ONLY_MAKE ONLY_MAKE_INCS ONLY_MAKE_LIBS)
+    cmake_parse_arguments(PKG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if (NOT PKG_LIB_PATH)
+    if(NOT PKG_LIB_PATH)
         set(PKG_LIB_PATH lib)
-    endif ()
+    endif()
 
     if(NOT PKG_EXE)
         set(PKG_EXE 0)
@@ -224,11 +225,11 @@ function(mindspore_add_pkg pkg_name )
     string(TOLOWER ${pkg_name} pkg_name)
     message("pkg name:${__FIND_PKG_NAME},${pkg_name}")
 
-    set(${pkg_name}_PATCHES_HASH )
+    set(${pkg_name}_PATCHES_HASH)
     foreach(_PATCH ${PKG_PATCHES})
         file(MD5 ${_PATCH} _PF_MD5)
         set(${pkg_name}_PATCHES_HASH "${${pkg_name}_PATCHES_HASH},${_PF_MD5}")
-    endforeach(_PATCH)
+    endforeach()
 
     # check options
     set(${pkg_name}_CONFIG_TXT
@@ -247,16 +248,16 @@ function(mindspore_add_pkg pkg_name )
         set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/${PKG_HEAD_ONLY} PARENT_SCOPE)
         add_library(${pkg_name} INTERFACE)
         target_include_directories(${pkg_name} INTERFACE ${${pkg_name}_INC})
-        if (${PKG_RELEASE})
+        if(${PKG_RELEASE})
             __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
-        endif ()
+        endif()
         return()
-    endif ()
+    endif()
 
     set(${__FIND_PKG_NAME}_ROOT ${${pkg_name}_BASE_DIR})
     set(${__FIND_PKG_NAME}_ROOT ${${pkg_name}_BASE_DIR} PARENT_SCOPE)
 
-    if (PKG_LIBS)
+    if(PKG_LIBS)
         __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
         if(${pkg_name}_LIBS)
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
@@ -265,28 +266,28 @@ function(mindspore_add_pkg pkg_name )
         endif()
     elseif(NOT PKG_HEAD_ONLY)
         find_package(${__FIND_PKG_NAME} ${PKG_VER} ${MS_FIND_NO_DEFAULT_PATH})
-        if (${__FIND_PKG_NAME}_FOUND)
+        if(${__FIND_PKG_NAME}_FOUND)
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
             message("Found pkg: ${__FIND_PKG_NAME}")
             return()
-        endif ()
-    endif ()
+        endif()
+    endif()
 
-    if (NOT PKG_DIR)
-        if (PKG_GIT_REPOSITORY)
+    if(NOT PKG_DIR)
+        if(PKG_GIT_REPOSITORY)
             __download_pkg_with_git(${pkg_name} ${PKG_GIT_REPOSITORY} ${PKG_GIT_TAG} ${PKG_MD5})
         else()
             __download_pkg(${pkg_name} ${PKG_URL} ${PKG_MD5})
         endif()
         foreach(_SUBMODULE_FILE ${PKG_SUBMODULES})
-            STRING( REGEX REPLACE "(.+)_(.+)" "\\1" _SUBMODEPATH ${_SUBMODULE_FILE})
-            STRING( REGEX REPLACE "(.+)/(.+)" "\\2" _SUBMODENAME ${_SUBMODEPATH})
+            STRING(REGEX REPLACE "(.+)_(.+)" "\\1" _SUBMODEPATH ${_SUBMODULE_FILE})
+            STRING(REGEX REPLACE "(.+)/(.+)" "\\2" _SUBMODENAME ${_SUBMODEPATH})
             file(GLOB ${pkg_name}_INSTALL_SUBMODULE ${_SUBMODULE_FILE}/*)
             file(COPY ${${pkg_name}_INSTALL_SUBMODULE} DESTINATION ${${pkg_name}_SOURCE_DIR}/3rdparty/${_SUBMODENAME})
-        endforeach (_SUBMODULE_FILE)
+        endforeach()
     else()
         set(${pkg_name}_SOURCE_DIR ${PKG_DIR})
-    endif ()
+    endif()
     file(WRITE ${${pkg_name}_BASE_DIR}/options.txt ${${pkg_name}_CONFIG_TXT})
     message("${pkg_name}_SOURCE_DIR : ${${pkg_name}_SOURCE_DIR}")
 
@@ -302,32 +303,32 @@ function(mindspore_add_pkg pkg_name )
         if(NOT Result EQUAL "0")
             message(FATAL_ERROR "Failed patch: ${_LF_PATCH_FILE}")
         endif()
-    endforeach(_PATCH_FILE)
+    endforeach()
     foreach(_SOURCE_DIR ${PKG_SOURCEMODULES})
         file(GLOB ${pkg_name}_INSTALL_SOURCE ${${pkg_name}_SOURCE_DIR}/${_SOURCE_DIR}/*)
         file(COPY ${${pkg_name}_INSTALL_SOURCE} DESTINATION ${${pkg_name}_BASE_DIR}/${_SOURCE_DIR}/)
-    endforeach (_SUBMODULE_FILE)
+    endforeach()
     file(LOCK ${${pkg_name}_BASE_DIR} DIRECTORY GUARD FUNCTION RESULT_VARIABLE ${pkg_name}_LOCK_RET TIMEOUT 600)
     if(NOT ${pkg_name}_LOCK_RET EQUAL "0")
         message(FATAL_ERROR "error! when try lock ${${pkg_name}_BASE_DIR} : ${${pkg_name}_LOCK_RET}")
     endif()
 
-    if (PKG_CUSTOM_CMAKE)
+    if(PKG_CUSTOM_CMAKE)
         file(GLOB ${pkg_name}_cmake ${PKG_CUSTOM_CMAKE}/CMakeLists.txt)
         file(COPY ${${pkg_name}_cmake} DESTINATION ${${pkg_name}_SOURCE_DIR})
-    endif ()
+    endif()
 
     if(${pkg_name}_SOURCE_DIR)
-        if (PKG_HEAD_ONLY)
+        if(PKG_HEAD_ONLY)
             file(GLOB ${pkg_name}_SOURCE_SUBDIRS ${${pkg_name}_SOURCE_DIR}/*)
             file(COPY ${${pkg_name}_SOURCE_SUBDIRS} DESTINATION ${${pkg_name}_BASE_DIR})
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/${PKG_HEAD_ONLY} PARENT_SCOPE)
-            if (NOT PKG_RELEASE)
+            if(NOT PKG_RELEASE)
                 add_library(${pkg_name} INTERFACE)
                 target_include_directories(${pkg_name} INTERFACE ${${pkg_name}_INC})
-            endif ()
+            endif()
 
-        elseif (PKG_ONLY_MAKE)
+        elseif(PKG_ONLY_MAKE)
             __exec_cmd(COMMAND ${CMAKE_MAKE_PROGRAM} ${${pkg_name}_CXXFLAGS} -j${THNUM}
                     WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR})
             set(PKG_INSTALL_INCS ${PKG_ONLY_MAKE_INCS})
@@ -337,23 +338,23 @@ function(mindspore_add_pkg pkg_name )
             file(COPY ${${pkg_name}_INSTALL_INCS} DESTINATION ${${pkg_name}_BASE_DIR}/include)
             file(COPY ${${pkg_name}_INSTALL_LIBS} DESTINATION ${${pkg_name}_BASE_DIR}/lib)
 
-        elseif (PKG_CMAKE_OPTION)
+        elseif(PKG_CMAKE_OPTION)
             # in cmake
             file(MAKE_DIRECTORY ${${pkg_name}_SOURCE_DIR}/_build)
-            if (${pkg_name}_CFLAGS)
+            if(${pkg_name}_CFLAGS)
                 set(${pkg_name}_CMAKE_CFLAGS "-DCMAKE_C_FLAGS=${${pkg_name}_CFLAGS}")
-            endif ()
-            if (${pkg_name}_CXXFLAGS)
+            endif()
+            if(${pkg_name}_CXXFLAGS)
                 set(${pkg_name}_CMAKE_CXXFLAGS "-DCMAKE_CXX_FLAGS=${${pkg_name}_CXXFLAGS}")
-            endif ()
+            endif()
 
-            if (${pkg_name}_LDFLAGS)
-                if (${pkg_name}_USE_STATIC_LIBS)
+            if(${pkg_name}_LDFLAGS)
+                if(${pkg_name}_USE_STATIC_LIBS)
                     #set(${pkg_name}_CMAKE_LDFLAGS "-DCMAKE_STATIC_LINKER_FLAGS=${${pkg_name}_LDFLAGS}")
                 else()
                     set(${pkg_name}_CMAKE_LDFLAGS "-DCMAKE_SHARED_LINKER_FLAGS=${${pkg_name}_LDFLAGS}")
-                endif ()
-            endif ()
+                endif()
+            endif()
 
             __exec_cmd(COMMAND ${CMAKE_COMMAND} ${PKG_CMAKE_OPTION} -G ${CMAKE_GENERATOR}
                     ${${pkg_name}_CMAKE_CFLAGS} ${${pkg_name}_CMAKE_CXXFLAGS} ${${pkg_name}_CMAKE_LDFLAGS}
@@ -364,48 +365,48 @@ function(mindspore_add_pkg pkg_name )
                     WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR}/_build)
 
         else()
-            if (${pkg_name}_CFLAGS)
+            if(${pkg_name}_CFLAGS)
                 set(${pkg_name}_MAKE_CFLAGS "CFLAGS=${${pkg_name}_CFLAGS}")
-            endif ()
-            if (${pkg_name}_CXXFLAGS)
+            endif()
+            if(${pkg_name}_CXXFLAGS)
                 set(${pkg_name}_MAKE_CXXFLAGS "CXXFLAGS=${${pkg_name}_CXXFLAGS}")
-            endif ()
-            if (${pkg_name}_LDFLAGS)
+            endif()
+            if(${pkg_name}_LDFLAGS)
                 set(${pkg_name}_MAKE_LDFLAGS "LDFLAGS=${${pkg_name}_LDFLAGS}")
-            endif ()
+            endif()
             # in configure && make
-            if (PKG_PRE_CONFIGURE_COMMAND)
+            if(PKG_PRE_CONFIGURE_COMMAND)
                 __exec_cmd(COMMAND ${PKG_PRE_CONFIGURE_COMMAND}
                         WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR})
-            endif ()
+            endif()
 
-            if (PKG_CONFIGURE_COMMAND)
+            if(PKG_CONFIGURE_COMMAND)
                 __exec_cmd(COMMAND ${PKG_CONFIGURE_COMMAND}
                         ${${pkg_name}_MAKE_CFLAGS} ${${pkg_name}_MAKE_CXXFLAGS} ${${pkg_name}_MAKE_LDFLAGS}
                         --prefix=${${pkg_name}_BASE_DIR}
                         WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR})
-            endif ()
+            endif()
             set(${pkg_name}_BUILD_OPTION ${PKG_BUILD_OPTION})
-            if (NOT PKG_CONFIGURE_COMMAND)
+            if(NOT PKG_CONFIGURE_COMMAND)
                 set(${pkg_name}_BUILD_OPTION ${${pkg_name}_BUILD_OPTION}
                         ${${pkg_name}_MAKE_CFLAGS} ${${pkg_name}_MAKE_CXXFLAGS} ${${pkg_name}_MAKE_LDFLAGS})
-            endif ()
+            endif()
             # build
             __exec_cmd(COMMAND ${CMAKE_MAKE_PROGRAM} ${${pkg_name}_BUILD_OPTION} -j${THNUM}
                     WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR})
 
-            if (PKG_INSTALL_INCS OR PKG_INSTALL_LIBS)
+            if(PKG_INSTALL_INCS OR PKG_INSTALL_LIBS)
                 file(GLOB ${pkg_name}_INSTALL_INCS ${${pkg_name}_SOURCE_DIR}/${PKG_INSTALL_INCS})
                 file(GLOB ${pkg_name}_INSTALL_LIBS ${${pkg_name}_SOURCE_DIR}/${PKG_INSTALL_LIBS})
                 file(COPY ${${pkg_name}_INSTALL_INCS} DESTINATION ${${pkg_name}_BASE_DIR}/include)
                 file(COPY ${${pkg_name}_INSTALL_LIBS} DESTINATION ${${pkg_name}_BASE_DIR}/lib)
             else()
                 __exec_cmd(COMMAND ${CMAKE_MAKE_PROGRAM} install WORKING_DIRECTORY ${${pkg_name}_SOURCE_DIR})
-            endif ()
-        endif ()
+            endif()
+        endif()
     endif()
 
-    if (PKG_LIBS)
+    if(PKG_LIBS)
         __find_pkg_then_add_target(${pkg_name} ${PKG_EXE} ${PKG_LIB_PATH} ${PKG_LIBS})
         set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
         if(NOT ${pkg_name}_LIBS)
@@ -413,10 +414,10 @@ function(mindspore_add_pkg pkg_name )
         endif()
     else()
         find_package(${__FIND_PKG_NAME} ${PKG_VER} QUIET ${MS_FIND_NO_DEFAULT_PATH})
-        if (${__FIND_PKG_NAME}_FOUND)
+        if(${__FIND_PKG_NAME}_FOUND)
             set(${pkg_name}_INC ${${pkg_name}_BASE_DIR}/include PARENT_SCOPE)
             message("Found pkg: ${${__FIND_PKG_NAME}_LIBRARIES}")
             return()
-        endif ()
-    endif ()
+        endif()
+    endif()
 endfunction()

mindspore_serving/ccsrc/common/file_system_operation.cc

@@ -34,6 +34,7 @@ bool DirOrFileExist(const std::string &file_path) {
 std::vector<std::string> GetAllSubDirs(const std::string &dir_path) {
   std::vector<std::string> SubDirs = GetAllSubDirsNotFullPath(dir_path);
   for (auto &item : SubDirs) {
+    // cppcheck-suppress useStlAlgorithm
     item = dir_path + "/" + item;
   }
   return SubDirs;

mindspore_serving/ccsrc/master/restful/http_process.cc

@@ -128,6 +128,7 @@ DataType RestfulService::GetObjDataType(const json &js) {
 
 std::string RestfulService::GetStringByDataType(DataType type) {
   for (const auto &item : str2_infer_type) {
+    // cppcheck-suppress useStlAlgorithm
     if (item.second == type) {
       return item.first;
     }

mindspore_serving/ccsrc/worker/context.cc

@@ -38,6 +38,7 @@ Status ServableContext::SetDeviceTypeStr(const std::string &device_type) {
   DeviceType type;
   std::string device_type_lowcase = device_type;
   for (auto &c : device_type_lowcase) {
+    // cppcheck-suppress useStlAlgorithm
     if (c >= 'A' && c <= 'Z') {
       c = c - 'A' + 'a';
     }

scripts/check_clang_format.sh

@@ -33,7 +33,7 @@ echo "SCRIPTS_PATH=$SCRIPTS_PATH"
 # print usage message
 function usage()
 {
-  echo "Check whether the specified source files were well formated"
+  echo "Check whether the specified source files were well formatted"
   echo "Usage:"
   echo "bash $0 [-a] [-c] [-l] [-h]"
   echo "e.g. $0 -a"
@@ -97,7 +97,7 @@ fi
 CHECK_RESULT_FILE=__code_format_check_result__
 echo "0" > "$CHECK_RESULT_FILE"
 
-# check format of files modified in the lastest commit 
+# check format of files modified in the latest commit
 while read line; do
   BASE_NAME=$(basename "${line}")
   TEMP_FILE="__TEMP__${BASE_NAME}"
@@ -107,7 +107,7 @@ while read line; do
   ret=$?
   rm "${TEMP_FILE}"
   if [[ "${ret}" -ne 0 ]]; then
-    echo "File ${line} is not formated, please format it."
+    echo "File ${line} is not formatted, please format it."
     echo "1" > "${CHECK_RESULT_FILE}"
     break
   fi
@@ -118,6 +118,6 @@ rm "${CHECK_RESULT_FILE}"
 rm "${CHECK_LIST_FILE}"
 cd "${CURRENT_PATH}" || exit 1
 if [[ "X${result}" == "X0" ]]; then
-  echo "Check PASS: specified files are well formated!"
+  echo "Check PASS: specified files are well formatted!"
 fi
 exit "${result}"