CMakeLists.txt

cmake_minimum_required(VERSION 3.14)
project (Lite)

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

set(MS_VERSION_MAJOY 0)
set(MS_VERSION_MINOR 7)
set(MS_VERSION_REVISION 0)

set(DIR_PREFIX mindspore-lite)
set(MS_VERSION ${MS_VERSION_MAJOY}.${MS_VERSION_MINOR}.${MS_VERSION_REVISION})
set(MAIN_DIR ${DIR_PREFIX}-${MS_VERSION})
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DMS_VERSION_MAJOY=${MS_VERSION_MAJOY} -DMS_VERSION_MINOR=${MS_VERSION_MINOR} -DMS_VERSION_REVISION=${MS_VERSION_REVISION}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMS_VERSION_MAJOY=${MS_VERSION_MAJOY} -DMS_VERSION_MINOR=${MS_VERSION_MINOR} -DMS_VERSION_REVISION=${MS_VERSION_REVISION}")

if (SUPPORT_GPU)
    set(PROCESS_UNIT gpu)
else ()
    set(PROCESS_UNIT cpu)
endif ()

if (PLATFORM_ARM64)
    set(COMPONENT_NAME runtime-arm64-${PROCESS_UNIT})
elseif (PLATFORM_ARM32)
    set(COMPONENT_NAME runtime-arm32-${PROCESS_UNIT})
else ()
    set(COMPONENT_NAME convert-ubuntu)
endif()
set(RUN_X86_COMPONENT_NAME runtime-x86-${PROCESS_UNIT})

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
set(TOP_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../..)
set(CORE_DIR ${TOP_DIR}/mindspore/core)
set(CCSRC_DIR ${TOP_DIR}/mindspore/ccsrc)
include_directories(${TOP_DIR})
include_directories(${CORE_DIR})
include_directories(${CCSRC_DIR})
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src/runtime/kernel/arm)
include_directories(${TOP_DIR}/third_party)
include_directories(${TOP_DIR}/third_party/flatbuffers/include)

include(${TOP_DIR}/cmake/utils.cmake)
include(${TOP_DIR}/cmake/dependency_utils.cmake)
include(${TOP_DIR}/cmake/dependency_securec.cmake)
if (WIN32)
    include(${TOP_DIR}/cmake/external_libs/protobuf.cmake)
    include(${TOP_DIR}/cmake/external_libs/flatbuffers.cmake)
endif()

option(CMAKE_BUILD_TYPE "build type" Release)
option(BUILD_DEVICE "if build device" on)
option(SUPPORT_TRAIN "if build for on-device train" off)
option(PLATFORM_ARM64 "if build device for arm64" off)
option(PLATFORM_ARM32 "if build device for arm32" off)
option(BUILD_CONVERTER "if build converter" on)
option(ENABLE_FP16 "if build fp16 ops" off)
option(SUPPORT_GPU "if support gpu" off)
option(OFFLINE_COMPILE "if offline compile OpenCL kernel" off)
option(BUILD_MINDDATA "" off)

set(CMAKE_VERBOSE_MAKEFILE on)
add_compile_definitions(USE_ANDROID_LOG)
add_compile_definitions(NO_DLIB)
add_compile_options(-fPIC)
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DDebug -g")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDebug -g")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=default")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=default")
else ()
    ## enable for binscope for release
    set(CMAKE_C_FLAGS "-fPIC -fPIE -D_FORTIFY_SOURCE=2 -O2 -Wall -Werror -fstack-protector-strong -Wno-attributes -Wno-deprecated-declarations -Wno-missing-braces ${CMAKE_C_FLAGS}")
    set(CMAKE_CXX_FLAGS "-fPIC -fPIE -D_FORTIFY_SOURCE=2 -O2 -Wall -Werror -fstack-protector-strong -Wno-attributes -Wno-deprecated-declarations -Wno-missing-braces -Wno-overloaded-virtual ${CMAKE_CXX_FLAGS}")
    if (NOT WIN32)
        set(CMAKE_SHARED_LINKER_FLAGS "-Wl,-z,relro,-z,now -Wl,-z,noexecstack ${CMAKE_SHARED_LINKER_FLAGS}")
        set(CMAKE_EXE_LINKER_FLAGS "-Wl,-z,relro,-z,now -Wl,-z,noexecstack ${CMAKE_EXE_LINKER_FLAGS}")
    endif()
    string(REPLACE    " -g " " " CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
endif ()

if (BUILD_DEVICE)
    add_compile_definitions(BUILD_DEVICE)
endif ()
if (SUPPORT_TRAIN)
    add_compile_definitions(SUPPORT_TRAIN)
endif()
if (ENABLE_NEON)
    add_compile_definitions(ENABLE_NEON)
endif ()
if (ENABLE_FP16)
    add_compile_definitions(ENABLE_FP16)
endif ()
if (SUPPORT_GPU)
    add_definitions(-DUSE_OPENCL_WRAPPER)
    add_definitions(-DMS_OPENCL_PROFILE=false)
    add_definitions(-DCL_HPP_TARGET_OPENCL_VERSION=200)
    add_compile_definitions(SUPPORT_GPU)
    if (OFFLINE_COMPILE)
        add_compile_definitions(PROGRAM_WITH_IL)
    endif ()
    include_directories(${TOP_DIR}/third_party/OpenCL-Headers)
    include_directories(${TOP_DIR}/third_party/OpenCL-CLHPP/include)
endif ()

if (WIN32)
    add_compile_definitions(LITE_EXPORTS)
    add_compile_definitions(BUILDING_DLL)
endif ()

set(ANF_SRC
        ${CMAKE_CURRENT_SOURCE_DIR}/../core/ir/meta_tensor.cc
        ${CORE_DIR}/gvar/logging_level.cc
        ${CORE_DIR}/gvar/typeid_manager.cc
        ${CMAKE_CURRENT_SOURCE_DIR}/../core/base/base.cc
        ${CMAKE_CURRENT_SOURCE_DIR}/src/common/log_adapter.cc
        )
if (BUILD_CONVERTER)
    if (PLATFORM_ARM64 OR PLATFORM_ARM32)
        MESSAGE(FATAL_ERROR "Cannot build converter in arm platform")
    endif()
    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)
                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})
                string(SUBSTRING ${Python3_LIBRARIES} 0 ${Python3_DIR_LEN} Python3_DIR)
                message("Python3_DIR: " ${Python3_DIR})
            endif ()
            link_directories(${Python3_DIR})
        endif ()
    else ()
        find_python_package(py_inc py_lib)
        set(PYTHON_INCLUDE_DIRS "${py_inc}")
        set(PYTHON_LIBRARIES "${py_lib}")
    endif ()
    include_directories(${PYTHON_INCLUDE_DIRS})
    include(${TOP_DIR}/cmake/external_libs/json.cmake)
    include(${TOP_DIR}/cmake/external_libs/pybind11.cmake)
    include(${TOP_DIR}/cmake/external_libs/eigen.cmake)
    include_directories(${TOP_DIR}/third_party/protobuf/build/include)
    link_directories(${TOP_DIR}/third_party/protobuf/build/lib)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tools/converter)
endif ()

if (BUILD_DEVICE)
    if (PLATFORM_ARM32 OR PLATFORM_ARM64)
        if (NOT DEFINED ENV{ANDROID_NDK})
            message(FATAL_ERROR "env ANDROID_NDK should be setted for ARM compile")
        endif ()
        add_compile_definitions(ENABLE_ARM)
    endif ()
    if (PLATFORM_ARM32)
        add_definitions(-mfloat-abi=softfp -mfpu=neon)
        add_compile_definitions(ENABLE_ARM32)
    endif ()
    if (PLATFORM_ARM64)
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv8.2-a+dotprod+fp16")
        add_compile_definitions(ENABLE_ARM64)
        if (ENABLE_FP16)
            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv8.2-a+dotprod+fp16")
        endif ()
    endif ()
endif ()

if (BUILD_MINDDATA)
    # opencv
    set(OpenCV_DIR ${TOP_DIR}/third_party/opencv/build)
    find_package(OpenCV REQUIRED)
    include_directories(${OpenCV_INCLUDE_DIRS})
    # json
    if (NOT BUILD_CONVERTER)
        include(${TOP_DIR}/cmake/external_libs/json.cmake)
    endif ()
    # eigen
    include_directories(${TOP_DIR}/third_party/eigen/)
    # jpeg-turbo
    add_library(jpeg-turbo SHARED IMPORTED)
    set_target_properties(jpeg-turbo PROPERTIES
        IMPORTED_LOCATION ${TOP_DIR}/third_party/libjpeg-turbo/lib/libturbojpeg.so
    )
    add_library(jpeg SHARED IMPORTED)
    set_target_properties(jpeg PROPERTIES
        IMPORTED_LOCATION ${TOP_DIR}/third_party/libjpeg-turbo/lib/libjpeg.so
    )
    include_directories(${TOP_DIR}/third_party/libjpeg-turbo/include)

    add_compile_definitions(ENABLE_ANDROID)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/minddata)
endif ()

if (BUILD_DEVICE)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/nnacl)
    if (NOT WIN32)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tools/benchmark)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/test)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/tools/time_profile)
    endif ()
endif ()

include(${TOP_DIR}/cmake/package_lite.cmake)