feat(cmake): format all cmake file

GitOrigin-RevId: 0a4ecab99b

cmake/BuildFlatBuffers.cmake

@@ -1,59 +1,56 @@
 # Copyright 2015 Google Inc. 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
+# 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
+# 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.
+# 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.
 
-# General function to create FlatBuffer build rules for the given list of
-# schemas.
+# General function to create FlatBuffer build rules for the given list of schemas.
 #
 # flatbuffers_schemas: A list of flatbuffer schema files to process.
 #
-# schema_include_dirs: A list of schema file include directories, which will be
-# passed to flatc via the -I parameter.
+# schema_include_dirs: A list of schema file include directories, which will be passed
+# to flatc via the -I parameter.
 #
-# custom_target_name: The generated files will be added as dependencies for a
-# new custom target with this name. You should add that target as a dependency
-# for your main target to ensure these files are built. You can also retrieve
-# various properties from this target, such as GENERATED_INCLUDES_DIR,
-# BINARY_SCHEMAS_DIR, and COPY_TEXT_SCHEMAS_DIR.
+# custom_target_name: The generated files will be added as dependencies for a new custom
+# target with this name. You should add that target as a dependency for your main target
+# to ensure these files are built. You can also retrieve various properties from this
+# target, such as GENERATED_INCLUDES_DIR, BINARY_SCHEMAS_DIR, and COPY_TEXT_SCHEMAS_DIR.
 #
-# additional_dependencies: A list of additional dependencies that you'd like
-# all generated files to depend on. Pass in a blank string if you have none.
+# additional_dependencies: A list of additional dependencies that you'd like all
+# generated files to depend on. Pass in a blank string if you have none.
 #
-# generated_includes_dir: Where to generate the C++ header files for these
-# schemas. The generated includes directory will automatically be added to
-# CMake's include directories, and will be where generated header files are
-# placed. This parameter is optional; pass in empty string if you don't want to
-# generate include files for these schemas.
+# generated_includes_dir: Where to generate the C++ header files for these schemas. The
+# generated includes directory will automatically be added to CMake's include
+# directories, and will be where generated header files are placed. This parameter is
+# optional; pass in empty string if you don't want to generate include files for these
+# schemas.
 #
-# binary_schemas_dir: If you specify an optional binary schema directory, binary
-# schemas will be generated for these schemas as well, and placed into the given
-# directory.
+# binary_schemas_dir: If you specify an optional binary schema directory, binary schemas
+# will be generated for these schemas as well, and placed into the given directory.
 #
-# copy_text_schemas_dir: If you want all text schemas (including schemas from
-# all schema include directories) copied into a directory (for example, if you
-# need them within your project to build JSON files), you can specify that
-# folder here. All text schemas will be copied to that folder.
+# copy_text_schemas_dir: If you want all text schemas (including schemas from all schema
+# include directories) copied into a directory (for example, if you need them within
+# your project to build JSON files), you can specify that folder here. All text schemas
+# will be copied to that folder.
 #
-# IMPORTANT: Make sure you quote all list arguments you pass to this function!
-# Otherwise CMake will only pass in the first element.
-# Example: build_flatbuffers("${fb_files}" "${include_dirs}" target_name ...)
-function(build_flatbuffers flatbuffers_schemas
-                           schema_include_dirs
-                           custom_target_name
-                           additional_dependencies
-                           generated_includes_dir
-                           binary_schemas_dir
-                           copy_text_schemas_dir)
+# IMPORTANT: Make sure you quote all list arguments you pass to this function! Otherwise
+# CMake will only pass in the first element. Example: build_flatbuffers("${fb_files}"
+# "${include_dirs}" target_name ...)
+function(
+  build_flatbuffers
+  flatbuffers_schemas
+  schema_include_dirs
+  custom_target_name
+  additional_dependencies
+  generated_includes_dir
+  binary_schemas_dir
+  copy_text_schemas_dir)
 
   # Test if including from FindFlatBuffers
   if(FLATBUFFERS_FLATC_EXECUTABLE)
@@ -65,10 +62,7 @@ function(build_flatbuffers flatbuffers_schemas
   endif()
   set(FLATC_SCHEMA_ARGS --gen-mutable)
   if(FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS)
-    set(FLATC_SCHEMA_ARGS
-      ${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS}
-      ${FLATC_SCHEMA_ARGS}
-      )
+    set(FLATC_SCHEMA_ARGS ${FLATBUFFERS_FLATC_SCHEMA_EXTRA_ARGS} ${FLATC_SCHEMA_ARGS})
   endif()
 
   set(working_dir "${CMAKE_CURRENT_SOURCE_DIR}")
@@ -77,12 +71,12 @@ function(build_flatbuffers flatbuffers_schemas
   # Generate the include files parameters.
   set(include_params "")
   set(all_generated_files "")
-  foreach (include_dir ${schema_include_dirs})
+  foreach(include_dir ${schema_include_dirs})
     set(include_params -I ${include_dir} ${include_params})
-    if (NOT ${copy_text_schemas_dir} STREQUAL "")
+    if(NOT ${copy_text_schemas_dir} STREQUAL "")
       # Copy text schemas from dependent folders.
       file(GLOB_RECURSE dependent_schemas ${include_dir}/${schema_glob})
-      foreach (dependent_schema ${dependent_schemas})
+      foreach(dependent_schema ${dependent_schemas})
         file(COPY ${dependent_schema} DESTINATION ${copy_text_schemas_dir})
       endforeach()
     endif()
@@ -91,62 +85,54 @@ function(build_flatbuffers flatbuffers_schemas
   foreach(schema ${flatbuffers_schemas})
     get_filename_component(filename ${schema} NAME_WE)
     # For each schema, do the things we requested.
-    if (NOT ${generated_includes_dir} STREQUAL "")
+    if(NOT ${generated_includes_dir} STREQUAL "")
       set(generated_include ${generated_includes_dir}/${filename}_generated.h)
       add_custom_command(
         OUTPUT ${generated_include}
-        COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS}
-        -o ${generated_includes_dir}
-        ${include_params}
-        -c ${schema}
+        COMMAND ${FLATC} ${FLATC_SCHEMA_ARGS} -o ${generated_includes_dir}
+                ${include_params} -c ${schema}
         DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies}
         WORKING_DIRECTORY "${working_dir}")
       list(APPEND all_generated_files ${generated_include})
     endif()
 
-    if (NOT ${binary_schemas_dir} STREQUAL "")
+    if(NOT ${binary_schemas_dir} STREQUAL "")
       set(binary_schema ${binary_schemas_dir}/${filename}.bfbs)
       add_custom_command(
         OUTPUT ${binary_schema}
-        COMMAND ${FLATC} -b --schema
-        -o ${binary_schemas_dir}
-        ${include_params}
-        ${schema}
+        COMMAND ${FLATC} -b --schema -o ${binary_schemas_dir} ${include_params}
+                ${schema}
         DEPENDS ${FLATC_TARGET} ${schema} ${additional_dependencies}
         WORKING_DIRECTORY "${working_dir}")
       list(APPEND all_generated_files ${binary_schema})
     endif()
 
-    if (NOT ${copy_text_schemas_dir} STREQUAL "")
+    if(NOT ${copy_text_schemas_dir} STREQUAL "")
       file(COPY ${schema} DESTINATION ${copy_text_schemas_dir})
     endif()
   endforeach()
 
-  # Create a custom target that depends on all the generated files.
-  # This is the target that you can depend on to trigger all these
-  # to be built.
-  add_custom_target(${custom_target_name}
-                    DEPENDS ${all_generated_files} ${additional_dependencies})
+  # Create a custom target that depends on all the generated files. This is the target
+  # that you can depend on to trigger all these to be built.
+  add_custom_target(${custom_target_name} DEPENDS ${all_generated_files}
+                                                  ${additional_dependencies})
 
   # Register the include directory we are using.
-  if (NOT ${generated_includes_dir} STREQUAL "")
+  if(NOT ${generated_includes_dir} STREQUAL "")
     include_directories(${generated_includes_dir})
-    set_property(TARGET ${custom_target_name}
-      PROPERTY GENERATED_INCLUDES_DIR
-      ${generated_includes_dir})
+    set_property(TARGET ${custom_target_name} PROPERTY GENERATED_INCLUDES_DIR
+                                                       ${generated_includes_dir})
   endif()
 
   # Register the binary schemas dir we are using.
-  if (NOT ${binary_schemas_dir} STREQUAL "")
-    set_property(TARGET ${custom_target_name}
-      PROPERTY BINARY_SCHEMAS_DIR
-      ${binary_schemas_dir})
+  if(NOT ${binary_schemas_dir} STREQUAL "")
+    set_property(TARGET ${custom_target_name} PROPERTY BINARY_SCHEMAS_DIR
+                                                       ${binary_schemas_dir})
   endif()
 
   # Register the text schema copy dir we are using.
-  if (NOT ${copy_text_schemas_dir} STREQUAL "")
-    set_property(TARGET ${custom_target_name}
-      PROPERTY COPY_TEXT_SCHEMAS_DIR
-      ${copy_text_schemas_dir})
+  if(NOT ${copy_text_schemas_dir} STREQUAL "")
+    set_property(TARGET ${custom_target_name} PROPERTY COPY_TEXT_SCHEMAS_DIR
+                                                       ${copy_text_schemas_dir})
   endif()
 endfunction()

cmake/FetchMegBrainVersion.cmake

@@ -1,49 +1,45 @@
-# Parses the version set in src/core/include/megbrain/version.h
-# Exports the following variables:
-# MGB_VER_MAJOR: Major version
-# MGB_VER_MINOR: Minor version
-# MGB_VER_PATCH: Patch version
-# MGB_IS_DEV: Is development version
-# MGB_VER_STRING: Version string
+# Parses the version set in src/core/include/megbrain/version.h Exports the following
+# variables: MGB_VER_MAJOR: Major version MGB_VER_MINOR: Minor version MGB_VER_PATCH:
+# Patch version MGB_IS_DEV: Is development version MGB_VER_STRING: Version string
 option(MGB_FORCE_DEV_VERSION "Force -dev tag in version stamp" OFF)
 
-file (READ "${CMAKE_CURRENT_SOURCE_DIR}/src/core/include/megbrain/version.h" content)
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/src/core/include/megbrain/version.h" content)
 
-string (REGEX MATCH "MGB_MAJOR +([0-9]+)" _ ${content})
-set (MGB_VER_MAJOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGB_MAJOR +([0-9]+)" _ ${content})
+set(MGB_VER_MAJOR ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGB_MINOR +([0-9]+)" _ ${content})
-set (MGB_VER_MINOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGB_MINOR +([0-9]+)" _ ${content})
+set(MGB_VER_MINOR ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGB_PATCH *([0-9]+)" _ ${content})
-set (MGB_VER_PATCH ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGB_PATCH *([0-9]+)" _ ${content})
+set(MGB_VER_PATCH ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGE_MAJOR +([0-9]+)" _ ${content})
-set (MGE_VER_MAJOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGE_MAJOR +([0-9]+)" _ ${content})
+set(MGE_VER_MAJOR ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGE_MINOR +([0-9]+)" _ ${content})
-set (MGE_VER_MINOR ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGE_MINOR +([0-9]+)" _ ${content})
+set(MGE_VER_MINOR ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGE_PATCH *([0-9]+)" _ ${content})
-set (MGE_VER_PATCH ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGE_PATCH *([0-9]+)" _ ${content})
+set(MGE_VER_PATCH ${CMAKE_MATCH_1})
 
-string (REGEX MATCH "MGE_EXTRA_NAME *\"(.*)\"" _ ${content})
-set (MGE_EXTRA_NAME ${CMAKE_MATCH_1})
+string(REGEX MATCH "MGE_EXTRA_NAME *\"(.*)\"" _ ${content})
+set(MGE_EXTRA_NAME ${CMAKE_MATCH_1})
 
-if (MGB_FORCE_DEV_VERSION)
-    set (MGB_IS_DEV 1)
+if(MGB_FORCE_DEV_VERSION)
+  set(MGB_IS_DEV 1)
 else()
-    string (REGEX MATCH "MGB_IS_DEV +([01])" _ ${content})
-    set (MGB_IS_DEV ${CMAKE_MATCH_1})
+  string(REGEX MATCH "MGB_IS_DEV +([01])" _ ${content})
+  set(MGB_IS_DEV ${CMAKE_MATCH_1})
 endif()
 
-if (DEFINED MGB_VER_MAJOR)
-    set (MGB_VER_STRING "${MGB_VER_MAJOR}.${MGB_VER_MINOR}.${MGB_VER_PATCH}")
+if(DEFINED MGB_VER_MAJOR)
+  set(MGB_VER_STRING "${MGB_VER_MAJOR}.${MGB_VER_MINOR}.${MGB_VER_PATCH}")
 else()
-    set (MGB_VER_STRING "${MGE_VER_MAJOR}.${MGE_VER_MINOR}.${MGE_VER_PATCH}")
+  set(MGB_VER_STRING "${MGE_VER_MAJOR}.${MGE_VER_MINOR}.${MGE_VER_PATCH}")
 endif(DEFINED MGB_VER_MAJOR)
-if (MGB_IS_DEV)
-    set (MGB_VER_STRING "${MGB_VER_STRING}-dev")
+if(MGB_IS_DEV)
+  set(MGB_VER_STRING "${MGB_VER_STRING}-dev")
 endif()
 
 message(STATUS "Building MegBrain ${MGB_VER_STRING}")

cmake/Halide.cmake

@@ -2,31 +2,40 @@
 include(ExternalProject)
 find_package(LLVM 6.0 REQUIRED CONFIG)
 
-STRING(REPLACE "." ";" LLVM_VERSION_LIST ${LLVM_PACKAGE_VERSION})
+string(REPLACE "." ";" LLVM_VERSION_LIST ${LLVM_PACKAGE_VERSION})
 list(GET LLVM_VERSION_LIST 0 LLVM_VERSION_MAJOR)
 list(GET LLVM_VERSION_LIST 1 LLVM_VERSION_MINOR)
 
-set(HALIDE_DIR "${PROJECT_SOURCE_DIR}/third_party/Halide" CACHE STRING "halide directory")
+set(HALIDE_DIR
+    "${PROJECT_SOURCE_DIR}/third_party/Halide"
+    CACHE STRING "halide directory")
 set(HALIDE_BUILD_DIR ${PROJECT_BINARY_DIR}/third_party/Halide)
 set(HALIDE_LIB ${HALIDE_BUILD_DIR}/lib/libHalide.a)
-ExternalProject_add(
-    halide
-    SOURCE_DIR ${HALIDE_DIR}
-    PREFIX ${HALIDE_BUILD_DIR}
-    CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DCMAKE_INSTALL_PREFIX=${HALIDE_BUILD_DIR} -DWITH_APPS=OFF -DWITH_TESTS=OFF -DWITH_TUTORIALS=OFF -DHALIDE_SHARED_LIBRARY=OFF -DHALIDE_REQUIRE_LLVM_VERSION=${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR} -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DTARGET_MIPS=OFF -DTARGET_POWERPC=OFF
-    BUILD_BYPRODUCTS ${HALIDE_LIB}
-)
+ExternalProject_Add(
+  halide
+  SOURCE_DIR ${HALIDE_DIR}
+  PREFIX ${HALIDE_BUILD_DIR}
+  CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+             -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+             -DCMAKE_INSTALL_PREFIX=${HALIDE_BUILD_DIR}
+             -DWITH_APPS=OFF
+             -DWITH_TESTS=OFF
+             -DWITH_TUTORIALS=OFF
+             -DHALIDE_SHARED_LIBRARY=OFF
+             -DHALIDE_REQUIRE_LLVM_VERSION=${LLVM_VERSION_MAJOR}${LLVM_VERSION_MINOR}
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+             -DTARGET_MIPS=OFF
+             -DTARGET_POWERPC=OFF
+  BUILD_BYPRODUCTS ${HALIDE_LIB})
 
 set(HALIDE_INC ${HALIDE_BUILD_DIR}/include)
 file(MAKE_DIRECTORY ${HALIDE_INC})
 add_library(libhalide STATIC IMPORTED GLOBAL)
 add_dependencies(libhalide halide)
-set_target_properties(
-    libhalide PROPERTIES
-    IMPORTED_LOCATION ${HALIDE_LIB}
-    INTERFACE_INCLUDE_DIRECTORIES ${HALIDE_INC}
-)
+set_target_properties(libhalide PROPERTIES IMPORTED_LOCATION ${HALIDE_LIB}
+                                           INTERFACE_INCLUDE_DIRECTORIES ${HALIDE_INC})
 
 set(LLVM_COMPONENTS mcjit;bitwriter;linker;passes;X86;ARM;AArch64;Hexagon;NVPTX;AMDGPU)
 llvm_map_components_to_libnames(HALIDE_LLVM_LIBS ${LLVM_COMPONENTS})
-

cmake/MKL_DNN.cmake

@@ -1,25 +1,31 @@
-if (MGE_USE_SYSTEM_LIB)
-    find_package(dnnl)
-    if (dnnl_FOUND)
-        message(STATUS "Using system provided MKL-DNN.")
-        set (MGE_USE_SYSTEM_MKLDNN ON)
-        return()
-    endif()
+if(MGE_USE_SYSTEM_LIB)
+  find_package(dnnl)
+  if(dnnl_FOUND)
+    message(STATUS "Using system provided MKL-DNN.")
+    set(MGE_USE_SYSTEM_MKLDNN ON)
+    return()
+  endif()
 endif()
 option(DNNL_BUILD_TESTS "" OFF)
 option(DNNL_BUILD_EXAMPLES "" OFF)
-# we do not want to use OMP now, so config to CPU mode
-# if set to OMP, some dnnl algo will be more fast
-set(DNNL_CPU_RUNTIME "SEQ" CACHE STRING "config dnnl to DNNL_RUNTIME_SEQ")
+# we do not want to use OMP now, so config to CPU mode if set to OMP, some dnnl algo
+# will be more fast
+set(DNNL_CPU_RUNTIME
+    "SEQ"
+    CACHE STRING "config dnnl to DNNL_RUNTIME_SEQ")
 if(MGE_BLAS STREQUAL "MKL")
-    option(_DNNL_USE_MKL "" ON)
-    set(MKLROOT ${MKL_ROOT_DIR} CACHE STRING "MKL ROOT FOR DNNL")
-    set(MKLLIB libmkl)
+  option(_DNNL_USE_MKL "" ON)
+  set(MKLROOT
+      ${MKL_ROOT_DIR}
+      CACHE STRING "MKL ROOT FOR DNNL")
+  set(MKLLIB libmkl)
 else()
-    option(_DNNL_USE_MKL "" OFF)
+  option(_DNNL_USE_MKL "" OFF)
 endif()
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter -Wno-extra")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter -Wno-extra")
-set(DNNL_LIBRARY_TYPE STATIC CACHE STRING "config dnnl to STATIC")
+set(DNNL_LIBRARY_TYPE
+    STATIC
+    CACHE STRING "config dnnl to STATIC")
 add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/intel-mkl-dnn)

cmake/Modules/FindNumPy.cmake

@@ -1,30 +1,28 @@
-# - Find the NumPy libraries
-# This module finds if NumPy is installed, and sets the following variables
-# indicating where it is.
+# * Find the NumPy libraries This module finds if NumPy is installed, and sets the
+#   following variables indicating where it is.
 #
 # TODO: Update to provide the libraries and paths for linking npymath lib.
 #
-#  NUMPY_FOUND               - was NumPy found
-#  NUMPY_VERSION             - the version of NumPy found as a string
-#  NUMPY_VERSION_MAJOR       - the major version number of NumPy
-#  NUMPY_VERSION_MINOR       - the minor version number of NumPy
-#  NUMPY_VERSION_PATCH       - the patch version number of NumPy
-#  NUMPY_VERSION_DECIMAL     - e.g. version 1.6.1 is 10601
-#  NUMPY_INCLUDE_DIR         - path to the NumPy include files
+# NUMPY_FOUND               - was NumPy found NUMPY_VERSION             - the version of
+# NumPy found as a string NUMPY_VERSION_MAJOR       - the major version number of NumPy
+# NUMPY_VERSION_MINOR       - the minor version number of NumPy NUMPY_VERSION_PATCH -
+# the patch version number of NumPy NUMPY_VERSION_DECIMAL     - e.g. version 1.6.1 is
+# 10601 NUMPY_INCLUDE_DIR         - path to the NumPy include files
 
 unset(NUMPY_VERSION)
 unset(NUMPY_INCLUDE_DIR)
 
 if(PYTHONINTERP_FOUND)
-  execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
-    "import numpy as n; print(n.__version__); print(n.get_include());"
+  execute_process(
+    COMMAND "${PYTHON_EXECUTABLE}" "-c"
+            "import numpy as n; print(n.__version__); print(n.get_include());"
     RESULT_VARIABLE __result
     OUTPUT_VARIABLE __output
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
   if(__result MATCHES 0)
     string(REGEX REPLACE ";" "\\\\;" __values ${__output})
-    string(REGEX REPLACE "\r?\n" ";"    __values ${__values})
+    string(REGEX REPLACE "\r?\n" ";" __values ${__values})
     list(GET __values 0 NUMPY_VERSION)
     list(GET __values 1 NUMPY_INCLUDE_DIR)
 
@@ -33,13 +31,18 @@ if(PYTHONINTERP_FOUND)
       set(NUMPY_VERSION_MAJOR ${CMAKE_MATCH_1})
       set(NUMPY_VERSION_MINOR ${CMAKE_MATCH_2})
       set(NUMPY_VERSION_PATCH ${CMAKE_MATCH_3})
-      math(EXPR NUMPY_VERSION_DECIMAL
-        "(${NUMPY_VERSION_MAJOR} * 10000) + (${NUMPY_VERSION_MINOR} * 100) + ${NUMPY_VERSION_PATCH}")
-      string(REGEX REPLACE "\\\\" "/"  NUMPY_INCLUDE_DIR ${NUMPY_INCLUDE_DIR})
+      math(
+        EXPR
+        NUMPY_VERSION_DECIMAL
+        "(${NUMPY_VERSION_MAJOR} * 10000) + (${NUMPY_VERSION_MINOR} * 100) + ${NUMPY_VERSION_PATCH}"
+      )
+      string(REGEX REPLACE "\\\\" "/" NUMPY_INCLUDE_DIR ${NUMPY_INCLUDE_DIR})
     else()
-     unset(NUMPY_VERSION)
-     unset(NUMPY_INCLUDE_DIR)
-     message(STATUS "Requested NumPy version and include path, but got instead:\n${__output}\n")
+      unset(NUMPY_VERSION)
+      unset(NUMPY_INCLUDE_DIR)
+      message(
+        STATUS
+          "Requested NumPy version and include path, but got instead:\n${__output}\n")
     endif()
   endif()
 else()
@@ -47,8 +50,10 @@ else()
 endif()
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(NumPy REQUIRED_VARS NUMPY_INCLUDE_DIR NUMPY_VERSION
-                                        VERSION_VAR   NUMPY_VERSION)
+find_package_handle_standard_args(
+  NumPy
+  REQUIRED_VARS NUMPY_INCLUDE_DIR NUMPY_VERSION
+  VERSION_VAR NUMPY_VERSION)
 
 if(NUMPY_FOUND)
   message(STATUS "NumPy ver. ${NUMPY_VERSION} found (include: ${NUMPY_INCLUDE_DIR})")

cmake/OpenBLAS.cmake

@@ -1,48 +1,50 @@
-if (MGE_USE_SYSTEM_LIB)
-    find_package(OpenBLAS)
-    set (MGE_USE_SYSTEM_OPENBLAS ON)
-
-    message(STATUS "Using system provided OpenBLAS ${OpenBLAS_VERSION}")
-    add_library(libopenblas IMPORTED GLOBAL)
-    set_target_properties(
-        libopenblas PROPERTIES
-        IMPORTED_LOCATION ${OpenBLAS_LIBRARIES}
-        INTERFACE_INCLUDE_DIRECTORIES ${OpenBLAS_INCLUDE_DIRS}
-    )
-    return()
+if(MGE_USE_SYSTEM_LIB)
+  find_package(OpenBLAS)
+  set(MGE_USE_SYSTEM_OPENBLAS ON)
+
+  message(STATUS "Using system provided OpenBLAS ${OpenBLAS_VERSION}")
+  add_library(libopenblas IMPORTED GLOBAL)
+  set_target_properties(
+    libopenblas PROPERTIES IMPORTED_LOCATION ${OpenBLAS_LIBRARIES}
+                           INTERFACE_INCLUDE_DIRECTORIES ${OpenBLAS_INCLUDE_DIRS})
+  return()
 endif()
 
 include(ExternalProject)
 include(GNUInstallDirs)
 
-set(OPENBLAS_DIR "${PROJECT_SOURCE_DIR}/third_party/OpenBLAS" CACHE STRING "OpenBLAS directory")
+set(OPENBLAS_DIR
+    "${PROJECT_SOURCE_DIR}/third_party/OpenBLAS"
+    CACHE STRING "OpenBLAS directory")
 set(OPENBLAS_BUILD_DIR ${PROJECT_BINARY_DIR}/third_party/OpenBLAS)
 
 set(OPENBLAS_INC ${OPENBLAS_BUILD_DIR}/include)
 set(OPENBLAS_LIB ${OPENBLAS_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libopenblas.a)
 
 if(${CMAKE_GENERATOR} STREQUAL "Ninja")
-    set(MAKE_COMMAND make)
+  set(MAKE_COMMAND make)
 else()
-    set(MAKE_COMMAND "$(MAKE)")
+  set(MAKE_COMMAND "$(MAKE)")
 endif()
 
-ExternalProject_add(
-    openblas
-    SOURCE_DIR ${OPENBLAS_DIR}
-    PREFIX ${OPENBLAS_BUILD_DIR}
-    CMAKE_GENERATOR "Unix Makefiles"
-    CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=${OPENBLAS_BUILD_DIR} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-    BUILD_COMMAND ${MAKE_COMMAND}
-    BUILD_BYPRODUCTS ${OPENBLAS_LIB} ${OPENBLAS_PROTOC_EXECUTABLE}
-)
+ExternalProject_Add(
+  openblas
+  SOURCE_DIR ${OPENBLAS_DIR}
+  PREFIX ${OPENBLAS_BUILD_DIR}
+  CMAKE_GENERATOR "Unix Makefiles"
+  CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+             -DCMAKE_INSTALL_PREFIX=${OPENBLAS_BUILD_DIR}
+             -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+  BUILD_COMMAND ${MAKE_COMMAND}
+  BUILD_BYPRODUCTS ${OPENBLAS_LIB} ${OPENBLAS_PROTOC_EXECUTABLE})
 
 file(MAKE_DIRECTORY ${OPENBLAS_INC})
 
 add_library(libopenblas STATIC IMPORTED GLOBAL)
 add_dependencies(libopenblas openblas)
 set_target_properties(
-    libopenblas PROPERTIES
-    IMPORTED_LOCATION ${OPENBLAS_LIB}
-    INTERFACE_INCLUDE_DIRECTORIES ${OPENBLAS_BUILD_DIR}/include
-)
+  libopenblas PROPERTIES IMPORTED_LOCATION ${OPENBLAS_LIB}
+                         INTERFACE_INCLUDE_DIRECTORIES ${OPENBLAS_BUILD_DIR}/include)

cmake/aclrt.cmake

@@ -1,31 +1,31 @@
-find_library(ACLRT_LIBRARY
-    NAMES libascendcl.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{ACLRT_HOME}/lib64/stub" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES stub
-    DOC "ACL library." )
+find_library(
+  ACLRT_LIBRARY
+  NAMES libascendcl.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{ACLRT_HOME}/lib64/stub" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES stub
+  DOC "ACL library.")
 
 if(ACLRT_LIBRARY STREQUAL "ACLRT_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find ACLRT Library")
+  message(FATAL_ERROR "Can not find ACLRT Library")
 endif()
 
 get_filename_component(__found_aclrt_root "${ACLRT_LIBRARY}/../../../" REALPATH)
-find_path(ACLRT_INCLUDE_DIR
-    NAMES acl/acl.h
-    HINTS "$ENV{ACLRT_HOME}/include" ${__found_aclrt_root}
-    PATH_SUFFIXES include
-    DOC "Path to ACLRT include directory." )
+find_path(
+  ACLRT_INCLUDE_DIR
+  NAMES acl/acl.h
+  HINTS "$ENV{ACLRT_HOME}/include" ${__found_aclrt_root}
+  PATH_SUFFIXES include
+  DOC "Path to ACLRT include directory.")
 
 if(ACLRT_INCLUDE_DIR STREQUAL "ACLRT_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find ACLRT Library")
+  message(FATAL_ERROR "Can not find ACLRT Library")
 endif()
 
 add_library(libascendcl SHARED IMPORTED)
 
-set_target_properties(libascendcl PROPERTIES
-    IMPORTED_LOCATION ${ACLRT_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${ACLRT_INCLUDE_DIR}
-)
+set_target_properties(
+  libascendcl PROPERTIES IMPORTED_LOCATION ${ACLRT_LIBRARY}
+                         INTERFACE_INCLUDE_DIRECTORIES ${ACLRT_INCLUDE_DIR})
 
 message(STATUS "Found ACLRT: ${__found_aclrt_root}")
-

cmake/cndev.cmake

@@ -1,44 +1,57 @@
-find_library(CNDEV_LIBRARY 
-    NAMES libcndev.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNDEV library." )
+find_library(
+  CNDEV_LIBRARY
+  NAMES libcndev.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNDEV library.")
 
 if(CNDEV_LIBRARY STREQUAL "CNDEV_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNDEV Library")
+  message(FATAL_ERROR "Can not find CNDEV Library")
 endif()
 
 get_filename_component(__found_cndev_root ${CNDEV_LIBRARY}/../.. REALPATH)
-find_path(CNDEV_INCLUDE_DIR 
-    NAMES cndev.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cndev_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNDEV include directory." )
+find_path(
+  CNDEV_INCLUDE_DIR
+  NAMES cndev.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cndev_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNDEV include directory.")
 
 if(CNDEV_INCLUDE_DIR STREQUAL "CNDEV_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNDEV Library")
+  message(FATAL_ERROR "Can not find CNDEV Library")
 endif()
 
-file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_1 REGEX "^#define CNDEV_VERSION_1 [0-9]+.*$")
-file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_2 REGEX "^#define CNDEV_VERSION_2 [0-9]+.*$")
-file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_3 REGEX "^#define CNDEV_VERSION_3 [0-9]+.*$")
-file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_4 REGEX "^#define CNDEV_VERSION_4 [0-9]+.*$")
-file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_5 REGEX "^#define CNDEV_VERSION_5 [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNDEV_VERSION_1 ([0-9]+).*$" "\\1" CNDEV_VERSION_1 "${CNDEV_1}")
-string(REGEX REPLACE "^#define CNDEV_VERSION_2 ([0-9]+).*$" "\\1" CNDEV_VERSION_2 "${CNDEV_2}")
-string(REGEX REPLACE "^#define CNDEV_VERSION_3 ([0-9]+).*$" "\\1" CNDEV_VERSION_3 "${CNDEV_3}")
-string(REGEX REPLACE "^#define CNDEV_VERSION_4 ([0-9]+).*$" "\\1" CNDEV_VERSION_4 "${CNDEV_4}")
-string(REGEX REPLACE "^#define CNDEV_VERSION_5 ([0-9]+).*$" "\\1" CNDEV_VERSION_5 "${CNDEV_5}")
-set(CNDEV_VERSION_STRING "${CNDEV_VERSION_1}.${CNDEV_VERSION_2}.${CNDEV_VERSION_3}.${CNDEV_VERSION_4}.${CNDEV_VERSION_5}")
+file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_1
+     REGEX "^#define CNDEV_VERSION_1 [0-9]+.*$")
+file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_2
+     REGEX "^#define CNDEV_VERSION_2 [0-9]+.*$")
+file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_3
+     REGEX "^#define CNDEV_VERSION_3 [0-9]+.*$")
+file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_4
+     REGEX "^#define CNDEV_VERSION_4 [0-9]+.*$")
+file(STRINGS "${CNDEV_INCLUDE_DIR}/cndev.h" CNDEV_5
+     REGEX "^#define CNDEV_VERSION_5 [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNDEV_VERSION_1 ([0-9]+).*$" "\\1" CNDEV_VERSION_1
+                     "${CNDEV_1}")
+string(REGEX REPLACE "^#define CNDEV_VERSION_2 ([0-9]+).*$" "\\1" CNDEV_VERSION_2
+                     "${CNDEV_2}")
+string(REGEX REPLACE "^#define CNDEV_VERSION_3 ([0-9]+).*$" "\\1" CNDEV_VERSION_3
+                     "${CNDEV_3}")
+string(REGEX REPLACE "^#define CNDEV_VERSION_4 ([0-9]+).*$" "\\1" CNDEV_VERSION_4
+                     "${CNDEV_4}")
+string(REGEX REPLACE "^#define CNDEV_VERSION_5 ([0-9]+).*$" "\\1" CNDEV_VERSION_5
+                     "${CNDEV_5}")
+set(CNDEV_VERSION_STRING
+    "${CNDEV_VERSION_1}.${CNDEV_VERSION_2}.${CNDEV_VERSION_3}.${CNDEV_VERSION_4}.${CNDEV_VERSION_5}"
+)
 
 add_library(libcndev SHARED IMPORTED)
 
-set_target_properties(libcndev PROPERTIES
-    IMPORTED_LOCATION ${CNDEV_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNDEV_INCLUDE_DIR}
-)
-
-message(STATUS "Found CNDEV: ${__found_cndev_root} (found version: ${CNDEV_VERSION_STRING})")
+set_target_properties(
+  libcndev PROPERTIES IMPORTED_LOCATION ${CNDEV_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                         ${CNDEV_INCLUDE_DIR})
 
+message(
+  STATUS "Found CNDEV: ${__found_cndev_root} (found version: ${CNDEV_VERSION_STRING})")

cmake/cnlight.cmake

@@ -1,40 +1,49 @@
-find_library(CNLIGHT_LIBRARY 
-    NAMES libcnlight.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNLIGHT library." )
+find_library(
+  CNLIGHT_LIBRARY
+  NAMES libcnlight.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNLIGHT library.")
 
 if(CNLIGHT_LIBRARY STREQUAL "CNLIGHT_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNLIGHT Library")
+  message(FATAL_ERROR "Can not find CNLIGHT Library")
 endif()
 
 get_filename_component(__found_cnlight_root "${CNLIGHT_LIBRARY}/../.." REALPATH)
-find_path(CNLIGHT_INCLUDE_DIR 
-    NAMES cnlight.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnlight_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNLIGHT include directory." )
+find_path(
+  CNLIGHT_INCLUDE_DIR
+  NAMES cnlight.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnlight_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNLIGHT include directory.")
 
 if(CNLIGHT_INCLUDE_DIR STREQUAL "CNLIGHT_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNLIGHT Library")
+  message(FATAL_ERROR "Can not find CNLIGHT Library")
 endif()
 
-file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_MAJOR REGEX "^#define CNLIGHT_MAJOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_MINOR REGEX "^#define CNLIGHT_MINOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_PATCH REGEX "^#define CNLIGHT_PATCH_VERSION [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNLIGHT_MAJOR_VERSION ([0-9]+).*$" "\\1" CNLIGHT_VERSION_MAJOR "${CNLIGHT_MAJOR}")
-string(REGEX REPLACE "^#define CNLIGHT_MINOR_VERSION ([0-9]+).*$" "\\1" CNLIGHT_VERSION_MINOR "${CNLIGHT_MINOR}")
-string(REGEX REPLACE "^#define CNLIGHT_PATCH_VERSION ([0-9]+).*$" "\\1" CNLIGHT_VERSION_PATCH "${CNLIGHT_PATCH}")
-set(CNLIGHT_VERSION_STRING "${CNLIGHT_VERSION_MAJOR}.${CNLIGHT_VERSION_MINOR}.${CNLIGHT_VERSION_PATCH}")
+file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_MAJOR
+     REGEX "^#define CNLIGHT_MAJOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_MINOR
+     REGEX "^#define CNLIGHT_MINOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNLIGHT_INCLUDE_DIR}/cnlight.h" CNLIGHT_PATCH
+     REGEX "^#define CNLIGHT_PATCH_VERSION [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNLIGHT_MAJOR_VERSION ([0-9]+).*$" "\\1"
+                     CNLIGHT_VERSION_MAJOR "${CNLIGHT_MAJOR}")
+string(REGEX REPLACE "^#define CNLIGHT_MINOR_VERSION ([0-9]+).*$" "\\1"
+                     CNLIGHT_VERSION_MINOR "${CNLIGHT_MINOR}")
+string(REGEX REPLACE "^#define CNLIGHT_PATCH_VERSION ([0-9]+).*$" "\\1"
+                     CNLIGHT_VERSION_PATCH "${CNLIGHT_PATCH}")
+set(CNLIGHT_VERSION_STRING
+    "${CNLIGHT_VERSION_MAJOR}.${CNLIGHT_VERSION_MINOR}.${CNLIGHT_VERSION_PATCH}")
 
 add_library(libcnlight SHARED IMPORTED)
 
-set_target_properties(libcnlight PROPERTIES
-    IMPORTED_LOCATION ${CNLIGHT_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNLIGHT_INCLUDE_DIR}
-)
-
-message(STATUS "Found CNLIGHT: ${__found_cnlight_root} (found version: ${CNLIGHT_VERSION_STRING})")
+set_target_properties(
+  libcnlight PROPERTIES IMPORTED_LOCATION ${CNLIGHT_LIBRARY}
+                        INTERFACE_INCLUDE_DIRECTORIES ${CNLIGHT_INCLUDE_DIR})
 
+message(
+  STATUS
+    "Found CNLIGHT: ${__found_cnlight_root} (found version: ${CNLIGHT_VERSION_STRING})")

cmake/cnml.cmake

@@ -1,40 +1,48 @@
-find_library(CNML_LIBRARY 
-    NAMES libcnml.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNML library." )
+find_library(
+  CNML_LIBRARY
+  NAMES libcnml.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNML library.")
 
 if(CNML_LIBRARY STREQUAL "CNML_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNML Library")
+  message(FATAL_ERROR "Can not find CNML Library")
 endif()
 
 get_filename_component(__found_cnml_root "${CNML_LIBRARY}/../.." REALPATH)
-find_path(CNML_INCLUDE_DIR 
-    NAMES cnml.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnml_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNML include directory." )
+find_path(
+  CNML_INCLUDE_DIR
+  NAMES cnml.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnml_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNML include directory.")
 
 if(CNML_INCLUDE_DIR STREQUAL "CNML_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNML Library")
+  message(FATAL_ERROR "Can not find CNML Library")
 endif()
 
-file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_MAJOR REGEX "^#define CNML_MAJOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_MINOR REGEX "^#define CNML_MINOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_PATCH REGEX "^#define CNML_PATCH_VERSION [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNML_MAJOR_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_MAJOR "${CNML_MAJOR}")
-string(REGEX REPLACE "^#define CNML_MINOR_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_MINOR "${CNML_MINOR}")
-string(REGEX REPLACE "^#define CNML_PATCH_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_PATCH "${CNML_PATCH}")
-set(CNML_VERSION_STRING "${CNML_VERSION_MAJOR}.${CNML_VERSION_MINOR}.${CNML_VERSION_PATCH}")
+file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_MAJOR
+     REGEX "^#define CNML_MAJOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_MINOR
+     REGEX "^#define CNML_MINOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNML_INCLUDE_DIR}/cnml.h" CNML_PATCH
+     REGEX "^#define CNML_PATCH_VERSION [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNML_MAJOR_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_MAJOR
+                     "${CNML_MAJOR}")
+string(REGEX REPLACE "^#define CNML_MINOR_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_MINOR
+                     "${CNML_MINOR}")
+string(REGEX REPLACE "^#define CNML_PATCH_VERSION ([0-9]+).*$" "\\1" CNML_VERSION_PATCH
+                     "${CNML_PATCH}")
+set(CNML_VERSION_STRING
+    "${CNML_VERSION_MAJOR}.${CNML_VERSION_MINOR}.${CNML_VERSION_PATCH}")
 
 add_library(libcnml SHARED IMPORTED)
 
-set_target_properties(libcnml PROPERTIES
-    IMPORTED_LOCATION ${CNML_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNML_INCLUDE_DIR}
-)
-
-message(STATUS "Found CNML: ${__found_cnml_root} (found version: ${CNML_VERSION_STRING})")
+set_target_properties(
+  libcnml PROPERTIES IMPORTED_LOCATION ${CNML_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                       ${CNML_INCLUDE_DIR})
 
+message(
+  STATUS "Found CNML: ${__found_cnml_root} (found version: ${CNML_VERSION_STRING})")

cmake/cnnl.cmake

@@ -1,80 +1,100 @@
-find_library(CNNL_LIBRARY 
-    NAMES libcnnl.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNNL library." )
+find_library(
+  CNNL_LIBRARY
+  NAMES libcnnl.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNNL library.")
 
 if(CNNL_LIBRARY STREQUAL "CNNL_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNNL Library")
+  message(FATAL_ERROR "Can not find CNNL Library")
 endif()
 
 get_filename_component(__found_cnnl_root "${CNNL_LIBRARY}/../.." REALPATH)
-find_path(CNNL_INCLUDE_DIR 
-    NAMES cnnl.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnnl_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNNL include directory." )
+find_path(
+  CNNL_INCLUDE_DIR
+  NAMES cnnl.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnnl_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNNL include directory.")
 
 if(CNNL_INCLUDE_DIR STREQUAL "CNNL_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNNL Library")
+  message(FATAL_ERROR "Can not find CNNL Library")
 endif()
 
-file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_MAJOR REGEX "^#define CNNL_MAJOR [0-9]+.*$")
-file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_MINOR REGEX "^#define CNNL_MINOR [0-9]+.*$")
-file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_PATCH REGEX "^#define CNNL_PATCHLEVEL [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNNL_MAJOR ([0-9]+).*$" "\\1" CNNL_VERSION_MAJOR "${CNNL_MAJOR}")
-string(REGEX REPLACE "^#define CNNL_MINOR ([0-9]+).*$" "\\1" CNNL_VERSION_MINOR "${CNNL_MINOR}")
-string(REGEX REPLACE "^#define CNNL_PATCHLEVEL ([0-9]+).*$" "\\1" CNNL_VERSION_PATCH "${CNNL_PATCH}")
-set(CNNL_VERSION_STRING "${CNNL_VERSION_MAJOR}.${CNNL_VERSION_MINOR}.${CNNL_VERSION_PATCH}")
+file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_MAJOR
+     REGEX "^#define CNNL_MAJOR [0-9]+.*$")
+file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_MINOR
+     REGEX "^#define CNNL_MINOR [0-9]+.*$")
+file(STRINGS "${CNNL_INCLUDE_DIR}/cnnl.h" CNNL_PATCH
+     REGEX "^#define CNNL_PATCHLEVEL [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNNL_MAJOR ([0-9]+).*$" "\\1" CNNL_VERSION_MAJOR
+                     "${CNNL_MAJOR}")
+string(REGEX REPLACE "^#define CNNL_MINOR ([0-9]+).*$" "\\1" CNNL_VERSION_MINOR
+                     "${CNNL_MINOR}")
+string(REGEX REPLACE "^#define CNNL_PATCHLEVEL ([0-9]+).*$" "\\1" CNNL_VERSION_PATCH
+                     "${CNNL_PATCH}")
+set(CNNL_VERSION_STRING
+    "${CNNL_VERSION_MAJOR}.${CNNL_VERSION_MINOR}.${CNNL_VERSION_PATCH}")
 
 add_library(libcnnl SHARED IMPORTED)
 
-set_target_properties(libcnnl PROPERTIES
-    IMPORTED_LOCATION ${CNNL_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNNL_INCLUDE_DIR}
-)
+set_target_properties(
+  libcnnl PROPERTIES IMPORTED_LOCATION ${CNNL_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                       ${CNNL_INCLUDE_DIR})
 
-message(STATUS "Found CNNL: ${__found_cnnl_root} (found version: ${CNNL_VERSION_STRING})")
+message(
+  STATUS "Found CNNL: ${__found_cnnl_root} (found version: ${CNNL_VERSION_STRING})")
 
-find_library(CNNL_EXTRA_LIBRARY 
-    NAMES libcnnl_extra.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNNL_EXTRA library." )
+find_library(
+  CNNL_EXTRA_LIBRARY
+  NAMES libcnnl_extra.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNNL_EXTRA library.")
 
 if(CNNL_EXTRA_LIBRARY STREQUAL "CNNL_EXTRA_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNNL_EXTRA Library")
+  message(FATAL_ERROR "Can not find CNNL_EXTRA Library")
 endif()
 
 get_filename_component(__found_cnnl_extra_root "${CNNL_EXTRA_LIBRARY}/../.." REALPATH)
-find_path(CNNL_EXTRA_INCLUDE_DIR 
-    NAMES cnnl_extra.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnnl_extra_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNNL_EXTRA include directory." )
+find_path(
+  CNNL_EXTRA_INCLUDE_DIR
+  NAMES cnnl_extra.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnnl_extra_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNNL_EXTRA include directory.")
 
 if(CNNL_EXTRA_INCLUDE_DIR STREQUAL "CNNL_EXTRA_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNNL_EXTRA Library")
+  message(FATAL_ERROR "Can not find CNNL_EXTRA Library")
 endif()
 
-file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_MAJOR REGEX "^#define CNNL_EXTRA_MAJOR [0-9]+.*$")
-file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_MINOR REGEX "^#define CNNL_EXTRA_MINOR [0-9]+.*$")
-file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_PATCH REGEX "^#define CNNL_EXTRA_PATCHLEVEL [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNNL_EXTRA_MAJOR ([0-9]+).*$" "\\1" CNNL_EXTRA_VERSION_MAJOR "${CNNL_EXTRA_MAJOR}")
-string(REGEX REPLACE "^#define CNNL_EXTRA_MINOR ([0-9]+).*$" "\\1" CNNL_EXTRA_VERSION_MINOR "${CNNL_EXTRA_MINOR}")
-string(REGEX REPLACE "^#define CNNL_EXTRA_PATCHLEVEL ([0-9]+).*$" "\\1" CNNL_EXTRA_VERSION_PATCH "${CNNL_EXTRA_PATCH}")
-set(CNNL_EXTRA_VERSION_STRING "${CNNL_EXTRA_VERSION_MAJOR}.${CNNL_EXTRA_VERSION_MINOR}.${CNNL_EXTRA_VERSION_PATCH}")
+file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_MAJOR
+     REGEX "^#define CNNL_EXTRA_MAJOR [0-9]+.*$")
+file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_MINOR
+     REGEX "^#define CNNL_EXTRA_MINOR [0-9]+.*$")
+file(STRINGS "${CNNL_EXTRA_INCLUDE_DIR}/cnnl_extra.h" CNNL_EXTRA_PATCH
+     REGEX "^#define CNNL_EXTRA_PATCHLEVEL [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNNL_EXTRA_MAJOR ([0-9]+).*$" "\\1"
+                     CNNL_EXTRA_VERSION_MAJOR "${CNNL_EXTRA_MAJOR}")
+string(REGEX REPLACE "^#define CNNL_EXTRA_MINOR ([0-9]+).*$" "\\1"
+                     CNNL_EXTRA_VERSION_MINOR "${CNNL_EXTRA_MINOR}")
+string(REGEX REPLACE "^#define CNNL_EXTRA_PATCHLEVEL ([0-9]+).*$" "\\1"
+                     CNNL_EXTRA_VERSION_PATCH "${CNNL_EXTRA_PATCH}")
+set(CNNL_EXTRA_VERSION_STRING
+    "${CNNL_EXTRA_VERSION_MAJOR}.${CNNL_EXTRA_VERSION_MINOR}.${CNNL_EXTRA_VERSION_PATCH}"
+)
 
 add_library(libcnnl_extra SHARED IMPORTED)
 
-set_target_properties(libcnnl_extra PROPERTIES
-    IMPORTED_LOCATION ${CNNL_EXTRA_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNNL_EXTRA_INCLUDE_DIR}
-)
-
-message(STATUS "Found CNNL_EXTRA: ${__found_cnnl_extra_root} (found version: ${CNNL_EXTRA_VERSION_STRING})")
+set_target_properties(
+  libcnnl_extra PROPERTIES IMPORTED_LOCATION ${CNNL_EXTRA_LIBRARY}
+                           INTERFACE_INCLUDE_DIRECTORIES ${CNNL_EXTRA_INCLUDE_DIR})
 
+message(
+  STATUS
+    "Found CNNL_EXTRA: ${__found_cnnl_extra_root} (found version: ${CNNL_EXTRA_VERSION_STRING})"
+)

cmake/cnrt.cmake

@@ -1,40 +1,48 @@
-find_library(CNRT_LIBRARY 
-    NAMES libcnrt.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "CNRT library." )
+find_library(
+  CNRT_LIBRARY
+  NAMES libcnrt.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "CNRT library.")
 
 if(CNRT_LIBRARY STREQUAL "CNRT_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNRT Library")
+  message(FATAL_ERROR "Can not find CNRT Library")
 endif()
 
 get_filename_component(__found_cnrt_root ${CNRT_LIBRARY}/../../ REALPATH)
-find_path(CNRT_INCLUDE_DIR 
-    NAMES cnrt.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnrt_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CNRT include directory." )
+find_path(
+  CNRT_INCLUDE_DIR
+  NAMES cnrt.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_cnrt_root}
+  PATH_SUFFIXES include
+  DOC "Path to CNRT include directory.")
 
 if(CNRT_INCLUDE_DIR STREQUAL "CNRT_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CNRT Library")
+  message(FATAL_ERROR "Can not find CNRT Library")
 endif()
 
-file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_MAJOR REGEX "^#define CNRT_MAJOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_MINOR REGEX "^#define CNRT_MINOR_VERSION [0-9]+.*$")
-file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_PATCH REGEX "^#define CNRT_PATCH_VERSION [0-9]+.*$")
-
-string(REGEX REPLACE "^#define CNRT_MAJOR_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_MAJOR "${CNRT_MAJOR}")
-string(REGEX REPLACE "^#define CNRT_MINOR_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_MINOR "${CNRT_MINOR}")
-string(REGEX REPLACE "^#define CNRT_PATCH_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_PATCH "${CNRT_PATCH}")
-set(CNRT_VERSION_STRING "${CNRT_VERSION_MAJOR}.${CNRT_VERSION_MINOR}.${CNRT_VERSION_PATCH}")
+file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_MAJOR
+     REGEX "^#define CNRT_MAJOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_MINOR
+     REGEX "^#define CNRT_MINOR_VERSION [0-9]+.*$")
+file(STRINGS "${CNRT_INCLUDE_DIR}/cnrt.h" CNRT_PATCH
+     REGEX "^#define CNRT_PATCH_VERSION [0-9]+.*$")
+
+string(REGEX REPLACE "^#define CNRT_MAJOR_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_MAJOR
+                     "${CNRT_MAJOR}")
+string(REGEX REPLACE "^#define CNRT_MINOR_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_MINOR
+                     "${CNRT_MINOR}")
+string(REGEX REPLACE "^#define CNRT_PATCH_VERSION ([0-9]+).*$" "\\1" CNRT_VERSION_PATCH
+                     "${CNRT_PATCH}")
+set(CNRT_VERSION_STRING
+    "${CNRT_VERSION_MAJOR}.${CNRT_VERSION_MINOR}.${CNRT_VERSION_PATCH}")
 
 add_library(libcnrt SHARED IMPORTED)
 
-set_target_properties(libcnrt PROPERTIES
-    IMPORTED_LOCATION ${CNRT_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CNRT_INCLUDE_DIR}
-)
-
-message(STATUS "Found CNRT: ${__found_cnrt_root} (found version: ${CNRT_VERSION_STRING})")
+set_target_properties(
+  libcnrt PROPERTIES IMPORTED_LOCATION ${CNRT_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                       ${CNRT_INCLUDE_DIR})
 
+message(
+  STATUS "Found CNRT: ${__found_cnrt_root} (found version: ${CNRT_VERSION_STRING})")

cmake/cpp_redis.cmake

@@ -1,2 +1,5 @@
-file(GLOB_RECURSE CPP_REDIS_SRCS ${PROJECT_SOURCE_DIR}/third_party/cpp_redis/sources/*.cpp ${PROJECT_SOURCE_DIR}/third_party/tacopie/sources/*.cpp)
-set(CPP_REDIS_INCLUDES ${PROJECT_SOURCE_DIR}/third_party/cpp_redis/includes ${PROJECT_SOURCE_DIR}/third_party/tacopie/includes)
+file(GLOB_RECURSE CPP_REDIS_SRCS
+     ${PROJECT_SOURCE_DIR}/third_party/cpp_redis/sources/*.cpp
+     ${PROJECT_SOURCE_DIR}/third_party/tacopie/sources/*.cpp)
+set(CPP_REDIS_INCLUDES ${PROJECT_SOURCE_DIR}/third_party/cpp_redis/includes
+                       ${PROJECT_SOURCE_DIR}/third_party/tacopie/includes)

cmake/cpuinfo.cmake

@@ -1,20 +1,20 @@
-if (MGE_USE_SYSTEM_LIB)
-    find_package(Cpuinfo)
-    message(STATUS "Using system provided cpuinfo ${cpuinfo_VERSION}")
-    add_library(libcpuinfo IMPORTED GLOBAL)
-    set_target_properties(
-        libcpuinfo PROPERTIES
-        IMPORTED_LOCATION ${cpuinfo_LIBRARIES}
-        INTERFACE_INCLUDE_DIRECTORIES ${cpuinfo_INCLUDE_DIRS}
-        )
-    return()
+if(MGE_USE_SYSTEM_LIB)
+  find_package(Cpuinfo)
+  message(STATUS "Using system provided cpuinfo ${cpuinfo_VERSION}")
+  add_library(libcpuinfo IMPORTED GLOBAL)
+  set_target_properties(
+    libcpuinfo PROPERTIES IMPORTED_LOCATION ${cpuinfo_LIBRARIES}
+                          INTERFACE_INCLUDE_DIRECTORIES ${cpuinfo_INCLUDE_DIRS})
+  return()
 endif()
 
-SET(CPUINFO_LIBRARY_TYPE "static" CACHE STRING "Type of cpuinfo library (shared, static, or default) to build")
-OPTION(CPUINFO_BUILD_TOOLS "Build command-line tools" OFF)
-OPTION(CPUINFO_BUILD_UNIT_TESTS "Build cpuinfo unit tests" OFF)
-OPTION(CPUINFO_BUILD_MOCK_TESTS "Build cpuinfo mock tests" OFF)
-OPTION(CPUINFO_BUILD_BENCHMARKS "Build cpuinfo micro-benchmarks" OFF)
+set(CPUINFO_LIBRARY_TYPE
+    "static"
+    CACHE STRING "Type of cpuinfo library (shared, static, or default) to build")
+option(CPUINFO_BUILD_TOOLS "Build command-line tools" OFF)
+option(CPUINFO_BUILD_UNIT_TESTS "Build cpuinfo unit tests" OFF)
+option(CPUINFO_BUILD_MOCK_TESTS "Build cpuinfo mock tests" OFF)
+option(CPUINFO_BUILD_BENCHMARKS "Build cpuinfo micro-benchmarks" OFF)
 include_directories("${PROJECT_SOURCE_DIR}/third_party/cpuinfo/include")
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/cpuinfo ${CMAKE_CURRENT_BINARY_DIR}/cpuinfo EXCLUDE_FROM_ALL)
-
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/cpuinfo
+                 ${CMAKE_CURRENT_BINARY_DIR}/cpuinfo EXCLUDE_FROM_ALL)

cmake/cudnn.cmake

@@ -1,73 +1,83 @@
 find_package(PkgConfig)
 if(${PkgConfig_FOUND})
-    pkg_check_modules(PC_CUDNN QUIET CUDNN)
+  pkg_check_modules(PC_CUDNN QUIET CUDNN)
 endif()
 
-if("${CUDNN_ROOT_DIR}" STREQUAL "" AND NOT "$ENV{CUDNN_ROOT_DIR}"  STREQUAL "")
-    set(CUDNN_ROOT_DIR $ENV{CUDNN_ROOT_DIR})
+if("${CUDNN_ROOT_DIR}" STREQUAL "" AND NOT "$ENV{CUDNN_ROOT_DIR}" STREQUAL "")
+  set(CUDNN_ROOT_DIR $ENV{CUDNN_ROOT_DIR})
 endif()
 
 if(MGE_CUDA_USE_STATIC AND NOT MGE_WITH_CUDNN_SHARED)
-    find_library(CUDNN_LIBRARY 
-        NAMES libcudnn_static.a cudnn.lib
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${CUDNN_ROOT_DIR} ${PC_CUDNN_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "CUDNN library." )
+  find_library(
+    CUDNN_LIBRARY
+    NAMES libcudnn_static.a cudnn.lib
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${CUDNN_ROOT_DIR} ${PC_CUDNN_LIBRARY_DIRS}
+          ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "CUDNN library.")
 else()
-    find_library(CUDNN_LIBRARY 
-        NAMES libcudnn.so libcudnn.dylib cudnn64.dll
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${CUDNN_ROOT_DIR} ${PC_CUDNN_LIBRARY_DIRS} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "CUDNN library." )
+  find_library(
+    CUDNN_LIBRARY
+    NAMES libcudnn.so libcudnn.dylib cudnn64.dll
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${CUDNN_ROOT_DIR} ${PC_CUDNN_LIBRARY_DIRS}
+          ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "CUDNN library.")
 endif()
 
 if(CUDNN_LIBRARY STREQUAL "CUDNN_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find CuDNN Library, please refer to scripts/cmake-build/BUILD_README.md to init CUDNN env")
+  message(
+    FATAL_ERROR
+      "Can not find CuDNN Library, please refer to scripts/cmake-build/BUILD_README.md to init CUDNN env"
+  )
 endif()
 
 get_filename_component(__found_cudnn_root ${CUDNN_LIBRARY}/../.. REALPATH)
-find_path(CUDNN_INCLUDE_DIR 
-    NAMES cudnn.h
-    HINTS $ENV{PC_CUDNN_INCLUDE_DIRS} ${CUDNN_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE} ${__found_cudnn_root}
-    PATH_SUFFIXES include 
-    DOC "Path to CUDNN include directory." )
+find_path(
+  CUDNN_INCLUDE_DIR
+  NAMES cudnn.h
+  HINTS $ENV{PC_CUDNN_INCLUDE_DIRS} ${CUDNN_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE}
+        ${__found_cudnn_root}
+  PATH_SUFFIXES include
+  DOC "Path to CUDNN include directory.")
 
 if(CUDNN_INCLUDE_DIR STREQUAL "CUDNN_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find CuDNN INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init CUDNN env")
+  message(
+    FATAL_ERROR
+      "Can not find CuDNN INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init CUDNN env"
+  )
 endif()
 
 if(EXISTS ${CUDNN_INCLUDE_DIR}/cudnn_version.h)
-    file(READ ${CUDNN_INCLUDE_DIR}/cudnn_version.h CUDNN_VERSION_FILE_CONTENTS)
+  file(READ ${CUDNN_INCLUDE_DIR}/cudnn_version.h CUDNN_VERSION_FILE_CONTENTS)
 else()
-    file(READ ${CUDNN_INCLUDE_DIR}/cudnn.h CUDNN_VERSION_FILE_CONTENTS)
+  file(READ ${CUDNN_INCLUDE_DIR}/cudnn.h CUDNN_VERSION_FILE_CONTENTS)
 endif()
 
-string(REGEX MATCH "define CUDNN_MAJOR * +([0-9]+)"
-    CUDNN_MAJOR_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
-string(REGEX REPLACE "define CUDNN_MAJOR * +([0-9]+)" "\\1"
-    CUDNN_MAJOR_VERSION "${CUDNN_MAJOR_VERSION}")
-string(REGEX MATCH "define CUDNN_MINOR * +([0-9]+)"
-    CUDNN_MINOR_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
-string(REGEX REPLACE "define CUDNN_MINOR * +([0-9]+)" "\\1"
-    CUDNN_MINOR_VERSION "${CUDNN_MINOR_VERSION}")
-string(REGEX MATCH "define CUDNN_PATCHLEVEL * +([0-9]+)"
-    CUDNN_PATCH_VERSION "${CUDNN_VERSION_FILE_CONTENTS}")
-string(REGEX REPLACE "define CUDNN_PATCHLEVEL * +([0-9]+)" "\\1"
-    CUDNN_PATCH_VERSION "${CUDNN_PATCH_VERSION}")  
+string(REGEX MATCH "define CUDNN_MAJOR * +([0-9]+)" CUDNN_MAJOR_VERSION
+             "${CUDNN_VERSION_FILE_CONTENTS}")
+string(REGEX REPLACE "define CUDNN_MAJOR * +([0-9]+)" "\\1" CUDNN_MAJOR_VERSION
+                     "${CUDNN_MAJOR_VERSION}")
+string(REGEX MATCH "define CUDNN_MINOR * +([0-9]+)" CUDNN_MINOR_VERSION
+             "${CUDNN_VERSION_FILE_CONTENTS}")
+string(REGEX REPLACE "define CUDNN_MINOR * +([0-9]+)" "\\1" CUDNN_MINOR_VERSION
+                     "${CUDNN_MINOR_VERSION}")
+string(REGEX MATCH "define CUDNN_PATCHLEVEL * +([0-9]+)" CUDNN_PATCH_VERSION
+             "${CUDNN_VERSION_FILE_CONTENTS}")
+string(REGEX REPLACE "define CUDNN_PATCHLEVEL * +([0-9]+)" "\\1" CUDNN_PATCH_VERSION
+                     "${CUDNN_PATCH_VERSION}")
 set(CUDNN_VERSION ${CUDNN_MAJOR_VERSION}.${CUDNN_MINOR_VERSION}.${CUDNN_PATCH_VERSION})
 
-
-
 if(MGE_CUDA_USE_STATIC)
-    add_library(libcudnn STATIC IMPORTED)
+  add_library(libcudnn STATIC IMPORTED)
 else()
-    add_library(libcudnn SHARED IMPORTED)
+  add_library(libcudnn SHARED IMPORTED)
 endif()
 
-set_target_properties(libcudnn PROPERTIES
-    IMPORTED_LOCATION ${CUDNN_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${CUDNN_INCLUDE_DIR})
+set_target_properties(
+  libcudnn PROPERTIES IMPORTED_LOCATION ${CUDNN_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                         ${CUDNN_INCLUDE_DIR})
 
 message(STATUS "Found CuDNN: ${__found_cudnn_root} (found version: ${CUDNN_VERSION})")

cmake/flatbuffers.cmake

@@ -1,27 +1,47 @@
-if (MGE_USE_SYSTEM_LIB)
-    find_package(Flatbuffers REQUIRED)
-    message(STATUS "Using system provided Flatbuffers ${Flatbuffers_VERSION}")
-    include(cmake/BuildFlatBuffers.cmake)
-    return()
+if(MGE_USE_SYSTEM_LIB)
+  find_package(Flatbuffers REQUIRED)
+  message(STATUS "Using system provided Flatbuffers ${Flatbuffers_VERSION}")
+  include(cmake/BuildFlatBuffers.cmake)
+  return()
 endif()
 if(MSVC OR WIN32)
-    message(DEBUG "add flags flatc for clang-cl build")
-    set(FLATC_FLAGS "")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=unknown-argument -Wno-error=c++98-compat -Wno-error=reserved-id-macro")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=sign-conversion -Wno-error=exceptions -Wno-error=argument-outside-range")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=delete-non-virtual-dtor -Wno-error=ignored-attributes -Wno-error=format")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=sign-compare -Wno-error=unused-private-field -Wno-error=braced-scalar-init")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=return-type-c-linkage -Wno-error=invalid-noreturn -Wno-error=c++98-compat-pedantic")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=extra-semi-stmt -Wno-error=missing-prototypes -Wno-error=documentation-unknown-command")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=missing-variable-declarations  -Wno-error=nonportable-system-include-path")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=exit-time-destructors -Wno-error=unused-macros -Wno-error=global-constructors")
-    set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=switch-enum -Wno-error=missing-noreturn -Wno-error=float-equal")
-    if (${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL "11.0.0")
-        set(FLATC_FLAGS "${FLATC_FLAGS} -Wno-error=suggest-override -Wno-error=suggest-destructor-override")
-    endif()
+  message(DEBUG "add flags flatc for clang-cl build")
+  set(FLATC_FLAGS "")
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=unknown-argument -Wno-error=c++98-compat -Wno-error=reserved-id-macro"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=sign-conversion -Wno-error=exceptions -Wno-error=argument-outside-range"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=delete-non-virtual-dtor -Wno-error=ignored-attributes -Wno-error=format"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=sign-compare -Wno-error=unused-private-field -Wno-error=braced-scalar-init"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=return-type-c-linkage -Wno-error=invalid-noreturn -Wno-error=c++98-compat-pedantic"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=extra-semi-stmt -Wno-error=missing-prototypes -Wno-error=documentation-unknown-command"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=missing-variable-declarations  -Wno-error=nonportable-system-include-path"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=exit-time-destructors -Wno-error=unused-macros -Wno-error=global-constructors"
+  )
+  set(FLATC_FLAGS
+      "${FLATC_FLAGS} -Wno-error=switch-enum -Wno-error=missing-noreturn -Wno-error=float-equal"
+  )
+  if(${CMAKE_CXX_COMPILER_VERSION} VERSION_GREATER_EQUAL "11.0.0")
+    set(FLATC_FLAGS
+        "${FLATC_FLAGS} -Wno-error=suggest-override -Wno-error=suggest-destructor-override"
+    )
+  endif()
 
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLATC_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATC_FLAGS}")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLATC_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLATC_FLAGS}")
 endif()
 
 option(FLATBUFFERS_BUILD_TESTS "" OFF)

cmake/gflags.cmake

@@ -1 +1,2 @@
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/gflags ${CMAKE_CURRENT_BINARY_DIR}/gflags)
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/gflags
+                 ${CMAKE_CURRENT_BINARY_DIR}/gflags)

cmake/gtest.cmake

@@ -1,2 +1,2 @@
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/gtest ${CMAKE_CURRENT_BINARY_DIR}/gtest EXCLUDE_FROM_ALL)
-
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/gtest
+                 ${CMAKE_CURRENT_BINARY_DIR}/gtest EXCLUDE_FROM_ALL)

cmake/llvm-project.cmake

@@ -1,88 +1,136 @@
-# - Find the llvm/mlir libraries
-# This module finds if llvm/mlir is installed, or build llvm/mlir from source.
-# This module sets the following variables.
+# * Find the llvm/mlir libraries This module finds if llvm/mlir is installed, or build
+#   llvm/mlir from source. This module sets the following variables.
 #
-#  MLIR_LLVM_INCLUDE_DIR     - path to the LLVM/MLIR include files
-#  MLIR_LLVM_LIBS            - path to the LLVM/MLIR libraries
+# MLIR_LLVM_INCLUDE_DIR     - path to the LLVM/MLIR include files MLIR_LLVM_LIBS - path
+# to the LLVM/MLIR libraries
 #
 # This module define the following functions.
 #
-# external_tablegen_library  - created interface library which depends on tablegen outputs
+# external_tablegen_library  - created interface library which depends on tablegen
+# outputs
 
 include(CMakeParseArguments)
 
 function(external_tablegen_library)
-    cmake_parse_arguments(
-        _RULE
-        "TESTONLY"
-        "NAME;TBLGEN"
-        "SRCS;INCLUDES;OUTS"
-        ${ARGN}
-        )
+  cmake_parse_arguments(_RULE "TESTONLY" "NAME;TBLGEN" "SRCS;INCLUDES;OUTS" ${ARGN})
 
-    if(_RULE_TESTONLY AND NOT MGE_WITH_TEST)
-        return()
-    endif()
+  if(_RULE_TESTONLY AND NOT MGE_WITH_TEST)
+    return()
+  endif()
 
-    set(_NAME ${_RULE_NAME})
+  set(_NAME ${_RULE_NAME})
 
-    set(LLVM_TARGET_DEFINITIONS ${_RULE_SRCS})
-    set(_INCLUDE_DIRS ${_RULE_INCLUDES})
-    list(TRANSFORM _INCLUDE_DIRS PREPEND "-I")
-    set(_OUTPUTS)
-    while(_RULE_OUTS)
-        list(GET _RULE_OUTS 0 _COMMAND)
-        list(REMOVE_AT _RULE_OUTS 0)
-        list(GET _RULE_OUTS 0 _FILE)
-        list(REMOVE_AT _RULE_OUTS 0)
-        tablegen(${_RULE_TBLGEN} ${_FILE} ${_COMMAND} ${_INCLUDE_DIRS})
-        list(APPEND _OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${_FILE})
-    endwhile()
-    add_custom_target(${_NAME}_target DEPENDS ${_OUTPUTS})
+  set(LLVM_TARGET_DEFINITIONS ${_RULE_SRCS})
+  set(_INCLUDE_DIRS ${_RULE_INCLUDES})
+  list(TRANSFORM _INCLUDE_DIRS PREPEND "-I")
+  set(_OUTPUTS)
+  while(_RULE_OUTS)
+    list(GET _RULE_OUTS 0 _COMMAND)
+    list(REMOVE_AT _RULE_OUTS 0)
+    list(GET _RULE_OUTS 0 _FILE)
+    list(REMOVE_AT _RULE_OUTS 0)
+    tablegen(${_RULE_TBLGEN} ${_FILE} ${_COMMAND} ${_INCLUDE_DIRS})
+    list(APPEND _OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${_FILE})
+  endwhile()
+  add_custom_target(${_NAME}_target DEPENDS ${_OUTPUTS})
 
-    add_library(${_NAME} INTERFACE)
-    add_dependencies(${_NAME} ${_NAME}_target)
+  add_library(${_NAME} INTERFACE)
+  add_dependencies(${_NAME} ${_NAME}_target)
 
-    target_include_directories(${_NAME} INTERFACE
-        "$<BUILD_INTERFACE:${_RULE_INCLUDES}>")
+  target_include_directories(${_NAME} INTERFACE "$<BUILD_INTERFACE:${_RULE_INCLUDES}>")
 
-    install(TARGETS ${_NAME} EXPORT ${MGE_EXPORT_TARGETS})
+  install(TARGETS ${_NAME} EXPORT ${MGE_EXPORT_TARGETS})
 endfunction()
 
-set(LLVM_LIBS LLVMCore LLVMSupport LLVMX86CodeGen LLVMOrcJIT LLVMNVPTXCodeGen LLVMNVPTXDesc LLVMNVPTXInfo)
-set(MLIR_CORE_LIBS MLIRAnalysis MLIRExecutionEngine MLIRIR MLIRParser MLIRPass MLIRSideEffectInterfaces MLIRTransforms)
-set(MLIR_DIALECT_LIBS MLIRAsync MLIRAVX512 MLIRGPU MLIRLLVMAVX512 MLIRNVVMIR MLIROpenACC MLIRPDL MLIRPDLInterp MLIRQuant MLIRROCDLIR MLIRSDBM MLIRShape MLIRSPIRV MLIRStandardOpsTransforms MLIRTosa)
-set(MLIR_CONVERSION_LIBS MLIRAffineToStandard MLIRAVX512ToLLVM MLIRGPUToGPURuntimeTransforms MLIRGPUToNVVMTransforms MLIRSCFToStandard)
+set(LLVM_LIBS
+    LLVMCore
+    LLVMSupport
+    LLVMX86CodeGen
+    LLVMOrcJIT
+    LLVMNVPTXCodeGen
+    LLVMNVPTXDesc
+    LLVMNVPTXInfo)
+set(MLIR_CORE_LIBS
+    MLIRAnalysis
+    MLIRExecutionEngine
+    MLIRIR
+    MLIRParser
+    MLIRPass
+    MLIRSideEffectInterfaces
+    MLIRTransforms)
+set(MLIR_DIALECT_LIBS
+    MLIRAsync
+    MLIRAVX512
+    MLIRGPU
+    MLIRLLVMAVX512
+    MLIRNVVMIR
+    MLIROpenACC
+    MLIRPDL
+    MLIRPDLInterp
+    MLIRQuant
+    MLIRROCDLIR
+    MLIRSDBM
+    MLIRShape
+    MLIRSPIRV
+    MLIRStandardOpsTransforms
+    MLIRTosa)
+set(MLIR_CONVERSION_LIBS
+    MLIRAffineToStandard MLIRAVX512ToLLVM MLIRGPUToGPURuntimeTransforms
+    MLIRGPUToNVVMTransforms MLIRSCFToStandard)
 set(MLIR_TRANSLATION_LIBS MLIRTargetLLVMIR MLIRTargetNVVMIR)
-set(MLIR_LIBS ${MLIR_CORE_LIBS} ${MLIR_DIALECT_LIBS} ${MLIR_CONVERSION_LIBS} ${MLIR_TRANSLATION_LIBS})
+set(MLIR_LIBS ${MLIR_CORE_LIBS} ${MLIR_DIALECT_LIBS} ${MLIR_CONVERSION_LIBS}
+              ${MLIR_TRANSLATION_LIBS})
 set(MLIR_LLVM_LIBS ${LLVM_LIBS} ${MLIR_LIBS})
 
 function(add_mge_mlir_src_dep llvm_monorepo_path)
-    set(_CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}")
-    string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
-    if(NOT uppercase_CMAKE_BUILD_TYPE MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
-        set(CMAKE_BUILD_TYPE "Debug")
-    endif()
-    set(_CMAKE_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
-    set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+  set(_CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}")
+  string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
+  if(NOT uppercase_CMAKE_BUILD_TYPE MATCHES
+     "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
+    set(CMAKE_BUILD_TYPE "Debug")
+  endif()
+  set(_CMAKE_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
+  set(BUILD_SHARED_LIBS
+      OFF
+      CACHE BOOL "" FORCE)
 
-    add_subdirectory("${llvm_monorepo_path}/llvm" ${LLVM_BUILD_DIR} EXCLUDE_FROM_ALL)
+  add_subdirectory("${llvm_monorepo_path}/llvm" ${LLVM_BUILD_DIR} EXCLUDE_FROM_ALL)
 
-    # Reset CMAKE_BUILD_TYPE to its previous setting
-    set(CMAKE_BUILD_TYPE "${_CMAKE_BUILD_TYPE}" CACHE STRING "Build type" FORCE)
-    # Reset BUILD_SHARED_LIBS to its previous setting
-    set(BUILD_SHARED_LIBS ${_CMAKE_BUILD_SHARED_LIBS} CACHE BOOL "Build shared libraries" FORCE)
+  # Reset CMAKE_BUILD_TYPE to its previous setting
+  set(CMAKE_BUILD_TYPE
+      "${_CMAKE_BUILD_TYPE}"
+      CACHE STRING "Build type" FORCE)
+  # Reset BUILD_SHARED_LIBS to its previous setting
+  set(BUILD_SHARED_LIBS
+      ${_CMAKE_BUILD_SHARED_LIBS}
+      CACHE BOOL "Build shared libraries" FORCE)
 endfunction()
 
 # llvm build options
-set(LLVM_INCLUDE_EXAMPLES OFF CACHE BOOL "" FORCE)
-set(LLVM_INCLUDE_TESTS OFF CACHE BOOL "" FORCE)
-set(LLVM_INCLUDE_DOCS OFF CACHE BOOL "" FORCE)
-set(LLVM_ENABLE_BINDINGS OFF CACHE BOOL "" FORCE)
-set(LLVM_INCLUDE_BENCHMARKS OFF CACHE BOOL "" FORCE)
-set(LLVM_ENABLE_RTTI ${MGE_ENABLE_RTTI} CACHE BOOL "" FORCE)
-set(LLVM_TARGETS_TO_BUILD "X86;NVPTX;AArch64;ARM" CACHE STRING "" FORCE)
-set(LLVM_ENABLE_PROJECTS "mlir" CACHE STRING "" FORCE)
+set(LLVM_INCLUDE_EXAMPLES
+    OFF
+    CACHE BOOL "" FORCE)
+set(LLVM_INCLUDE_TESTS
+    OFF
+    CACHE BOOL "" FORCE)
+set(LLVM_INCLUDE_DOCS
+    OFF
+    CACHE BOOL "" FORCE)
+set(LLVM_ENABLE_BINDINGS
+    OFF
+    CACHE BOOL "" FORCE)
+set(LLVM_INCLUDE_BENCHMARKS
+    OFF
+    CACHE BOOL "" FORCE)
+set(LLVM_ENABLE_RTTI
+    ${MGE_ENABLE_RTTI}
+    CACHE BOOL "" FORCE)
+set(LLVM_TARGETS_TO_BUILD
+    "X86;NVPTX;AArch64;ARM"
+    CACHE STRING "" FORCE)
+set(LLVM_ENABLE_PROJECTS
+    "mlir"
+    CACHE STRING "" FORCE)
 set(LLVM_BUILD_DIR ${PROJECT_BINARY_DIR}/third_party/llvm-project/llvm)
 
 add_mge_mlir_src_dep("third_party/llvm-project")
@@ -91,6 +139,5 @@ set(MLIR_LLVM_INCLUDE_DIR
     ${PROJECT_SOURCE_DIR}/third_party/llvm-project/llvm/include
     ${PROJECT_BINARY_DIR}/third_party/llvm-project/llvm/include
     ${PROJECT_SOURCE_DIR}/third_party/llvm-project/mlir/include
-    ${PROJECT_BINARY_DIR}/third_party/llvm-project/llvm/tools/mlir/include
-    )
+    ${PROJECT_BINARY_DIR}/third_party/llvm-project/llvm/tools/mlir/include)
 set(MLIR_TABLEGEN_EXE mlir-tblgen)

cmake/magicmind.cmake

@@ -1,54 +1,64 @@
-find_library(MAGICMIND_LIBRARY 
-    NAMES libmagicmind.so
-    PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
-    HINTS ${ALTER_LIBRARY_PATHS}
-    PATH_SUFFIXES lib lib64
-    DOC "MAGICMIND library." )
+find_library(
+  MAGICMIND_LIBRARY
+  NAMES libmagicmind.so
+  PATHS ${ALTER_LD_LIBRARY_PATHS} "$ENV{NEUWARE_HOME}/lib64" ${CMAKE_INSTALL_PREFIX}
+  HINTS ${ALTER_LIBRARY_PATHS}
+  PATH_SUFFIXES lib lib64
+  DOC "MAGICMIND library.")
 
 if(MAGICMIND_LIBRARY STREQUAL "MAGICMIND_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find MAGICMIND Library")
+  message(FATAL_ERROR "Can not find MAGICMIND Library")
 endif()
 
 get_filename_component(__found_magicmind_root "${MAGICMIND_LIBRARY}/../../" REALPATH)
-find_path(MAGICMIND_INCLUDE_DIR 
-    NAMES common.h
-    HINTS "$ENV{NEUWARE_HOME}/include" ${__found_magicmind_root}
-    PATH_SUFFIXES include 
-    DOC "Path to MAGICMIND include directory." )
+find_path(
+  MAGICMIND_INCLUDE_DIR
+  NAMES common.h
+  HINTS "$ENV{NEUWARE_HOME}/include" ${__found_magicmind_root}
+  PATH_SUFFIXES include
+  DOC "Path to MAGICMIND include directory.")
 
 if(MAGICMIND_INCLUDE_DIR STREQUAL "MAGICMIND_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find MAGICMIND Library")
+  message(FATAL_ERROR "Can not find MAGICMIND Library")
 endif()
 
-file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_MAJOR REGEX "^#define MM_MAJOR_VERSION [0-9]+.*$")
-file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_MINOR REGEX "^#define MM_MINOR_VERSION [0-9]+.*$")
-file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_PATCH REGEX "^#define MM_PATCH_VERSION [0-9]+.*$")
+file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_MAJOR
+     REGEX "^#define MM_MAJOR_VERSION [0-9]+.*$")
+file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_MINOR
+     REGEX "^#define MM_MINOR_VERSION [0-9]+.*$")
+file(STRINGS "${MAGICMIND_INCLUDE_DIR}/common.h" MAGICMIND_PATCH
+     REGEX "^#define MM_PATCH_VERSION [0-9]+.*$")
 
-string(REGEX REPLACE "^#define MM_MAJOR_VERSION ([0-9]+).*$" "\\1" MAGICMIND_VERSION_MAJOR "${MAGICMIND_MAJOR}")
-string(REGEX REPLACE "^#define MM_MINOR_VERSION ([0-9]+).*$" "\\1" MAGICMIND_VERSION_MINOR "${MAGICMIND_MINOR}")
-string(REGEX REPLACE "^#define MM_PATCH_VERSION ([0-9]+).*$" "\\1" MAGICMIND_VERSION_PATCH "${MAGICMIND_PATCH}")
-set(MAGICMIND_VERSION_STRING "${MAGICMIND_VERSION_MAJOR}.${MAGICMIND_VERSION_MINOR}.${MAGICMIND_VERSION_PATCH}")
+string(REGEX REPLACE "^#define MM_MAJOR_VERSION ([0-9]+).*$" "\\1"
+                     MAGICMIND_VERSION_MAJOR "${MAGICMIND_MAJOR}")
+string(REGEX REPLACE "^#define MM_MINOR_VERSION ([0-9]+).*$" "\\1"
+                     MAGICMIND_VERSION_MINOR "${MAGICMIND_MINOR}")
+string(REGEX REPLACE "^#define MM_PATCH_VERSION ([0-9]+).*$" "\\1"
+                     MAGICMIND_VERSION_PATCH "${MAGICMIND_PATCH}")
+set(MAGICMIND_VERSION_STRING
+    "${MAGICMIND_VERSION_MAJOR}.${MAGICMIND_VERSION_MINOR}.${MAGICMIND_VERSION_PATCH}")
 
 add_library(libmagicmind SHARED IMPORTED)
 
-set_target_properties(libmagicmind PROPERTIES
-    IMPORTED_LOCATION ${MAGICMIND_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${MAGICMIND_INCLUDE_DIR}
-)
+set_target_properties(
+  libmagicmind PROPERTIES IMPORTED_LOCATION ${MAGICMIND_LIBRARY}
+                          INTERFACE_INCLUDE_DIRECTORIES ${MAGICMIND_INCLUDE_DIR})
 
-message(STATUS "Found MAGICMIND: ${__found_magicmind_root} (found version: ${MAGICMIND_VERSION_STRING})")
+message(
+  STATUS
+    "Found MAGICMIND: ${__found_magicmind_root} (found version: ${MAGICMIND_VERSION_STRING})"
+)
 
-find_library(MAGICMIND_RUNTIME_LIBRARY 
-    NAMES libmagicmind_runtime.so
-    PATHS "${__found_magicmind_root}/lib64"
-    )
+find_library(
+  MAGICMIND_RUNTIME_LIBRARY
+  NAMES libmagicmind_runtime.so
+  PATHS "${__found_magicmind_root}/lib64")
 
 if(MAGICMIND_RUNTIME_LIBRARY STREQUAL "MAGICMIND_RUNTIME_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find MAGICMIND_RUNTIME Library")
+  message(FATAL_ERROR "Can not find MAGICMIND_RUNTIME Library")
 else()
-    message(STATUS "Found MAGICMIND_RUNTIME: ${MAGICMIND_RUNTIME_LIBRARY}")
+  message(STATUS "Found MAGICMIND_RUNTIME: ${MAGICMIND_RUNTIME_LIBRARY}")
 endif()
 add_library(libmagicmind_runtime SHARED IMPORTED)
-set_target_properties(libmagicmind_runtime PROPERTIES
-    IMPORTED_LOCATION ${MAGICMIND_RUNTIME_LIBRARY}
-)
+set_target_properties(libmagicmind_runtime PROPERTIES IMPORTED_LOCATION
+                                                      ${MAGICMIND_RUNTIME_LIBRARY})

cmake/mkl.cmake

@@ -1,77 +1,83 @@
-find_path(MKL_ROOT_DIR
-    include/mkl_cblas.h
-    PATHS
-    ${PROJECT_SOURCE_DIR}/third_party/mkl/${MGE_ARCH}
-    ${PROJECT_SOURCE_DIR}/third_party/mkl/${MGE_ARCH}/Library
-    ${PROJECT_SOURCE_DIR}/third_party/mkl/x86_32/Library
-    ${PROJECT_SOURCE_DIR}/third_party/mkl/x86_32
-    $ENV{MKLDIR}
-    /opt/intel/mkl/*/
-    /opt/intel/cmkl/*/
-    /Library/Frameworks/Intel_MKL.framework/Versions/Current/lib/universal
-)
+find_path(
+  MKL_ROOT_DIR include/mkl_cblas.h
+  PATHS ${PROJECT_SOURCE_DIR}/third_party/mkl/${MGE_ARCH}
+        ${PROJECT_SOURCE_DIR}/third_party/mkl/${MGE_ARCH}/Library
+        ${PROJECT_SOURCE_DIR}/third_party/mkl/x86_32/Library
+        ${PROJECT_SOURCE_DIR}/third_party/mkl/x86_32
+        $ENV{MKLDIR}
+        /opt/intel/mkl/*/
+        /opt/intel/cmkl/*/
+        /Library/Frameworks/Intel_MKL.framework/Versions/Current/lib/universal)
 
 if(${MKL_ROOT_DIR} STREQUAL "MKL_ROOT_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find MKL")
+  message(FATAL_ERROR "Can not find MKL")
 endif()
 message(STATUS "Build with MKL in ${MKL_ROOT_DIR}")
 
-find_path(MKL_INCLUDE_DIR
-    mkl_cblas.h
-    PATHS
-    ${MKL_ROOT_DIR}/include
-    ${INCLUDE_INSTALL_DIR}
-)
+find_path(MKL_INCLUDE_DIR mkl_cblas.h PATHS ${MKL_ROOT_DIR}/include
+                                            ${INCLUDE_INSTALL_DIR})
 
 option(MGE_MKL_USE_STATIC "Build MegEngine with static MKL" ON)
 if(MGE_MKL_USE_STATIC)
-    find_library(MKL_CORE_LIBRARY
-        NAMES libmkl_core.a mkl_core.lib
-        PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  find_library(
+    MKL_CORE_LIBRARY
+    NAMES libmkl_core.a mkl_core.lib
+    PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
 
-    find_library(MKL_SEQUENTIAL_LIBRARY
-        NAMES libmkl_sequential.a mkl_sequential.lib
-        PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  find_library(
+    MKL_SEQUENTIAL_LIBRARY
+    NAMES libmkl_sequential.a mkl_sequential.lib
+    PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
 
-    if(${MGE_ARCH} STREQUAL "x86_64")
-        find_library(MKL_IPL_LIBRARY
-            NAMES libmkl_intel_ilp64.a mkl_intel_ilp64.lib
-            PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
-    elseif(${MGE_ARCH} STREQUAL "i386")
-        find_library(MKL_IPL_LIBRARY
-            NAMES libmkl_intel_32.a mkl_intel_32.lib mkl_intel_c.lib
-            PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
-    endif()
+  if(${MGE_ARCH} STREQUAL "x86_64")
+    find_library(
+      MKL_IPL_LIBRARY
+      NAMES libmkl_intel_ilp64.a mkl_intel_ilp64.lib
+      PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  elseif(${MGE_ARCH} STREQUAL "i386")
+    find_library(
+      MKL_IPL_LIBRARY
+      NAMES libmkl_intel_32.a mkl_intel_32.lib mkl_intel_c.lib
+      PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  endif()
 
-    add_library(libmkl INTERFACE IMPORTED)
-    if(UNIX AND NOT APPLE)
-        target_link_libraries(libmkl INTERFACE -Wl,--start-group ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY} -Wl,--end-group)
-    else()
-        target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY})
-    endif()
-    target_include_directories(libmkl INTERFACE ${MKL_INCLUDE_DIR})
+  add_library(libmkl INTERFACE IMPORTED)
+  if(UNIX AND NOT APPLE)
+    target_link_libraries(
+      libmkl INTERFACE -Wl,--start-group ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY}
+                       ${MKL_IPL_LIBRARY} -Wl,--end-group)
+  else()
+    target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY}
+                                           ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY})
+  endif()
+  target_include_directories(libmkl INTERFACE ${MKL_INCLUDE_DIR})
 else()
-    find_library(MKL_CORE_LIBRARY
-        NAMES libmkl_core.so libmkl_core.dylib
-        PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  find_library(
+    MKL_CORE_LIBRARY
+    NAMES libmkl_core.so libmkl_core.dylib
+    PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
 
-    find_library(MKL_SEQUENTIAL_LIBRARY
-        NAMES libmkl_sequential.so libmkl_sequential.dylib
-        PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  find_library(
+    MKL_SEQUENTIAL_LIBRARY
+    NAMES libmkl_sequential.so libmkl_sequential.dylib
+    PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
 
-    if(${MGE_ARCH} STREQUAL "x86_64")
-        find_library(MKL_IPL_LIBRARY
-            NAMES libmkl_intel_ilp64.so libmkl_intel_ilp64.dylib
-            PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
-    elseif(${MGE_ARCH} STREQUAL "x86_32")
-        find_library(MKL_IPL_LIBRARY
-            NAMES libmkl_intel_32.so libmkl_intel_32.dylib
-            PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
-    endif()
-    target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY} ${MKL_IPL_LIBRARY})
-    target_include_directories(libmkl INTERFACE ${MKL_INCLUDE_DIR})
+  if(${MGE_ARCH} STREQUAL "x86_64")
+    find_library(
+      MKL_IPL_LIBRARY
+      NAMES libmkl_intel_ilp64.so libmkl_intel_ilp64.dylib
+      PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  elseif(${MGE_ARCH} STREQUAL "x86_32")
+    find_library(
+      MKL_IPL_LIBRARY
+      NAMES libmkl_intel_32.so libmkl_intel_32.dylib
+      PATHS ${MKL_ROOT_DIR}/lib/${MKL_ARCH_DIR} ${MKL_ROOT_DIR}/lib/)
+  endif()
+  target_link_libraries(libmkl INTERFACE ${MKL_CORE_LIBRARY} ${MKL_SEQUENTIAL_LIBRARY}
+                                         ${MKL_IPL_LIBRARY})
+  target_include_directories(libmkl INTERFACE ${MKL_INCLUDE_DIR})
 endif()
 
 if(${MGE_ARCH} STREQUAL "x86_64")
-    target_compile_definitions(libmkl INTERFACE -DMKL_ILP64)
+  target_compile_definitions(libmkl INTERFACE -DMKL_ILP64)
 endif()

cmake/protobuf.cmake

@@ -1,70 +1,83 @@
 function(PROTOBUF_GENERATE_CPP_WITH_ROOT SRCS HDRS ROOT_DIR)
-    if(NOT ARGN)
-        message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP_WITH_ROOT() called without any proto files")
-        return()
-    endif()
+  if(NOT ARGN)
+    message(
+      SEND_ERROR
+        "Error: PROTOBUF_GENERATE_CPP_WITH_ROOT() called without any proto files")
+    return()
+  endif()
 
-    set(${SRCS})
-    set(${HDRS})
-    foreach(FIL ${ARGN})
-        set(ABS_FIL ${ROOT_DIR}/${FIL})
-        get_filename_component(FIL_WE ${FIL} NAME_WE)
-        get_filename_component(FIL_DIR ${ABS_FIL} PATH)
-        file(RELATIVE_PATH REL_DIR ${ROOT_DIR} ${FIL_DIR})
+  set(${SRCS})
+  set(${HDRS})
+  foreach(FIL ${ARGN})
+    set(ABS_FIL ${ROOT_DIR}/${FIL})
+    get_filename_component(FIL_WE ${FIL} NAME_WE)
+    get_filename_component(FIL_DIR ${ABS_FIL} PATH)
+    file(RELATIVE_PATH REL_DIR ${ROOT_DIR} ${FIL_DIR})
 
-        list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc")
-        list(APPEND ${HDRS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h")
+    list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc")
+    list(APPEND ${HDRS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h")
 
-        add_custom_command(
-            OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc"
-                   "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
-            COMMAND ${PROTOBUF_PROTOC_EXECUTABLE}
-            ARGS --cpp_out ${CMAKE_CURRENT_BINARY_DIR} -I ${FIL_DIR} ${ABS_FIL} -I ${PROTOBUF_INCLUDE_DIRS}
-            DEPENDS ${ABS_FIL} libprotobuf
-            COMMENT "Running C++ protocol buffer compiler on ${FIL}"
-            VERBATIM)
-    endforeach()
+    add_custom_command(
+      OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.cc"
+             "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}.pb.h"
+      COMMAND ${PROTOBUF_PROTOC_EXECUTABLE} ARGS --cpp_out ${CMAKE_CURRENT_BINARY_DIR}
+              -I ${FIL_DIR} ${ABS_FIL} -I ${PROTOBUF_INCLUDE_DIRS}
+      DEPENDS ${ABS_FIL} libprotobuf
+      COMMENT "Running C++ protocol buffer compiler on ${FIL}"
+      VERBATIM)
+  endforeach()
 
-    set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
-    set(${SRCS} ${${SRCS}} PARENT_SCOPE)
-    set(${HDRS} ${${HDRS}} PARENT_SCOPE)
+  set_source_files_properties(${${SRCS}} ${${HDRS}} PROPERTIES GENERATED TRUE)
+  set(${SRCS}
+      ${${SRCS}}
+      PARENT_SCOPE)
+  set(${HDRS}
+      ${${HDRS}}
+      PARENT_SCOPE)
 endfunction()
 
 if(MGE_USE_SYSTEM_LIB)
-    find_package(Protobuf)
-    if(Protobuf_FOUND)
-        add_library(libprotobuf INTERFACE)
-        target_link_libraries(libprotobuf INTERFACE ${Protobuf_LIBRARIES})
-        target_include_directories(libprotobuf INTERFACE ${Protobuf_INCLUDE_DIRS})
-        get_filename_component(Protobuf_ROOT ${Protobuf_INCLUDE_DIR} DIRECTORY)
-        set(PROTOBUF_ROOT ${Protobuf_ROOT})
-        set(PROTOBUF_PROTOC_EXECUTABLE ${Protobuf_PROTOC_EXECUTABLE})
-        set(PROTOBUF_INCLUDE_DIRS ${Protobuf_INCLUDE_DIRS})
-        return()
-    endif()
+  find_package(Protobuf)
+  if(Protobuf_FOUND)
+    add_library(libprotobuf INTERFACE)
+    target_link_libraries(libprotobuf INTERFACE ${Protobuf_LIBRARIES})
+    target_include_directories(libprotobuf INTERFACE ${Protobuf_INCLUDE_DIRS})
+    get_filename_component(Protobuf_ROOT ${Protobuf_INCLUDE_DIR} DIRECTORY)
+    set(PROTOBUF_ROOT ${Protobuf_ROOT})
+    set(PROTOBUF_PROTOC_EXECUTABLE ${Protobuf_PROTOC_EXECUTABLE})
+    set(PROTOBUF_INCLUDE_DIRS ${Protobuf_INCLUDE_DIRS})
+    return()
+  endif()
 endif()
 
-
 include(ExternalProject)
 include(GNUInstallDirs)
 
-set(PROTOBUF_DIR "${PROJECT_SOURCE_DIR}/third_party/protobuf" CACHE STRING "protobuf directory")
+set(PROTOBUF_DIR
+    "${PROJECT_SOURCE_DIR}/third_party/protobuf"
+    CACHE STRING "protobuf directory")
 set(PROTOBUF_BUILD_DIR ${PROJECT_BINARY_DIR}/third_party/protobuf)
 
 if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-    set(PROTOBUF_LIB ${PROTOBUF_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libprotobufd.a)
+  set(PROTOBUF_LIB ${PROTOBUF_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libprotobufd.a)
 else()
-    set(PROTOBUF_LIB ${PROTOBUF_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libprotobuf.a)
+  set(PROTOBUF_LIB ${PROTOBUF_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libprotobuf.a)
 endif()
 set(PROTOBUF_PROTOC_EXECUTABLE ${PROTOBUF_BUILD_DIR}/bin/protoc)
 
-ExternalProject_add(
-    protobuf
-    SOURCE_DIR ${PROTOBUF_DIR}/cmake
-    PREFIX ${PROTOBUF_BUILD_DIR}
-    CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_INSTALL_PREFIX=${PROTOBUF_BUILD_DIR} -Dprotobuf_BUILD_EXAMPLES=OFF -Dprotobuf_BUILD_TESTS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-    BUILD_BYPRODUCTS ${PROTOBUF_LIB} ${PROTOBUF_PROTOC_EXECUTABLE}
-)
+ExternalProject_Add(
+  protobuf
+  SOURCE_DIR ${PROTOBUF_DIR}/cmake
+  PREFIX ${PROTOBUF_BUILD_DIR}
+  CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+             -DCMAKE_INSTALL_PREFIX=${PROTOBUF_BUILD_DIR}
+             -Dprotobuf_BUILD_EXAMPLES=OFF
+             -Dprotobuf_BUILD_TESTS=OFF
+             -DBUILD_SHARED_LIBS=OFF
+             -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+  BUILD_BYPRODUCTS ${PROTOBUF_LIB} ${PROTOBUF_PROTOC_EXECUTABLE})
 
 set(PROTOBUF_INC ${PROTOBUF_BUILD_DIR}/include)
 file(MAKE_DIRECTORY ${PROTOBUF_INC})
@@ -72,19 +85,14 @@ file(MAKE_DIRECTORY ${PROTOBUF_INC})
 add_library(libprotobuf STATIC IMPORTED GLOBAL)
 add_dependencies(libprotobuf protobuf)
 set_target_properties(
-    libprotobuf PROPERTIES
-    IMPORTED_LOCATION ${PROTOBUF_LIB}
-    INTERFACE_INCLUDE_DIRECTORIES ${PROTOBUF_BUILD_DIR}/include
-)
+  libprotobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_LIB}
+                         INTERFACE_INCLUDE_DIRECTORIES ${PROTOBUF_BUILD_DIR}/include)
 
 add_executable(protoc IMPORTED GLOBAL)
 add_dependencies(protoc protobuf)
-set_target_properties(
-    protoc PROPERTIES
-    IMPORTED_LOCATION ${PROTOBUF_BUILD_DIR}/bin/protoc
-)
+set_target_properties(protoc PROPERTIES IMPORTED_LOCATION
+                                        ${PROTOBUF_BUILD_DIR}/bin/protoc)
 
 set(PROTOBUF_ROOT ${PROTOBUF_BUILD_DIR})
 set(PROTOBUF_PROTOC_EXECUTABLE protoc)
 set(PROTOBUF_INCLUDE_DIRS ${PROTOBUF_BUILD_DIR}/include)
-

cmake/rocm.cmake

@@ -1,28 +1,34 @@
 if(NOT DEFINED HIP_PATH)
-    if(NOT DEFINED ENV{HIP_PATH})
-        set(HIP_PATH "/opt/rocm/hip" CACHE PATH "Path to which HIP has been installed")
-    else()
-        set(HIP_PATH $ENV{HIP_PATH} CACHE PATH "Path to which HIP has been installed")
-    endif()
+  if(NOT DEFINED ENV{HIP_PATH})
+    set(HIP_PATH
+        "/opt/rocm/hip"
+        CACHE PATH "Path to which HIP has been installed")
+  else()
+    set(HIP_PATH
+        $ENV{HIP_PATH}
+        CACHE PATH "Path to which HIP has been installed")
+  endif()
 endif()
 set(CMAKE_MODULE_PATH "${HIP_PATH}/cmake" ${CMAKE_MODULE_PATH})
 find_package(HIP QUIET)
-if (HIP_FOUND)
-    message(STATUS "Found HIP: " ${HIP_VERSION})
+if(HIP_FOUND)
+  message(STATUS "Found HIP: " ${HIP_VERSION})
 else()
-    message(FATAL_ERROR "Could not find HIP. Ensure that HIP is either installed in /opt/rocm/hip or the variable HIP_PATH is set to point to the right location.")
+  message(
+    FATAL_ERROR
+      "Could not find HIP. Ensure that HIP is either installed in /opt/rocm/hip or the variable HIP_PATH is set to point to the right location."
+  )
 endif()
 
-if (${HIP_VERSION} VERSION_LESS 3.0)
-    message(FATAL_ERROR "ROCM version needed 3. Please update ROCM.")
+if(${HIP_VERSION} VERSION_LESS 3.0)
+  message(FATAL_ERROR "ROCM version needed 3. Please update ROCM.")
 endif()
 
 macro(hipconfig_get_option variable option)
-    if(NOT DEFINED ${variable})
-        execute_process(
-            COMMAND ${HIP_HIPCONFIG_EXECUTABLE} ${option}
-            OUTPUT_VARIABLE ${variable})
-    endif()
+  if(NOT DEFINED ${variable})
+    execute_process(COMMAND ${HIP_HIPCONFIG_EXECUTABLE} ${option}
+                    OUTPUT_VARIABLE ${variable})
+  endif()
 endmacro()
 
 hipconfig_get_option(HIP_COMPILER "--compiler")
@@ -31,30 +37,33 @@ hipconfig_get_option(HIP_CPP_CONFIG "--cpp_config")
 separate_arguments(HIP_CPP_CONFIG)
 
 foreach(hip_config_item ${HIP_CPP_CONFIG})
-    foreach(macro_name "__HIP_PLATFORM_HCC__" "__HIP_ROCclr__")
-        if(${hip_config_item} STREQUAL "-D${macro_name}=")
-            set(HIP_CPP_DEFINE "${HIP_CPP_DEFINE}#define ${macro_name}\n")
-            set(HIP_CPP_UNDEFINE "${HIP_CPP_UNDEFINE}\
+  foreach(macro_name "__HIP_PLATFORM_HCC__" "__HIP_ROCclr__")
+    if(${hip_config_item} STREQUAL "-D${macro_name}=")
+      set(HIP_CPP_DEFINE "${HIP_CPP_DEFINE}#define ${macro_name}\n")
+      set(HIP_CPP_UNDEFINE
+          "${HIP_CPP_UNDEFINE}\
                     #ifdef ${macro_name}\n#undef ${macro_name}\n\
                     #else\n#error\n\
                     #endif\n")
-        elseif(${hip_config_item} STREQUAL "-D${macro_name}")
-            set(HIP_CPP_DEFINE "${HIP_CPP_DEFINE}#define ${macro_name} 1\n")
-            set(HIP_CPP_UNDEFINE "${HIP_CPP_UNDEFINE}\
+    elseif(${hip_config_item} STREQUAL "-D${macro_name}")
+      set(HIP_CPP_DEFINE "${HIP_CPP_DEFINE}#define ${macro_name} 1\n")
+      set(HIP_CPP_UNDEFINE
+          "${HIP_CPP_UNDEFINE}\
                     #ifdef ${macro_name}\n#undef ${macro_name}\n\
                     #else\n#error\n\
                     #endif\n")
-        endif()
-    endforeach()
+    endif()
+  endforeach()
 endforeach()
 
 message(STATUS "Using HIP compiler ${HIP_COMPILER}")
 
 if(${HIP_COMPILER} STREQUAL "hcc")
-    set(MGE_ROCM_LIBS hip_hcc)
-    message(WARNING "hcc is not well supported, please modify link.txt to link with hipcc")
-elseif (${HIP_COMPILER} STREQUAL "clang")
-    set(MGE_ROCM_LIBS amdhip64)
+  set(MGE_ROCM_LIBS hip_hcc)
+  message(
+    WARNING "hcc is not well supported, please modify link.txt to link with hipcc")
+elseif(${HIP_COMPILER} STREQUAL "clang")
+  set(MGE_ROCM_LIBS amdhip64)
 endif()
 
 list(APPEND MGE_ROCM_LIBS amdocl64 MIOpen rocblas rocrand)
@@ -63,26 +72,28 @@ set(HIP_INCLUDE_DIR ${HIP_ROOT_DIR}/../include)
 set(HIP_LIBRARY_DIR ${HIP_ROOT_DIR}/../lib)
 
 function(find_rocm_library name dirname include library)
-    find_path(${name}_LIBRARY_DIR
-        NAMES ${library}
-        HINTS "${${name}_ROOT_DIR}" "${HIP_ROOT_DIR}/../${dirname}"
-        PATH_SUFFIXES lib lib/x86_64
-        DOC "Path to ${name} library directory")
+  find_path(
+    ${name}_LIBRARY_DIR
+    NAMES ${library}
+    HINTS "${${name}_ROOT_DIR}" "${HIP_ROOT_DIR}/../${dirname}"
+    PATH_SUFFIXES lib lib/x86_64
+    DOC "Path to ${name} library directory")
 
-    if(${${name}_LIBRARY_DIR} MATCHES "NOTFOUND$")
-        message(FATAL_ERROR "Can not find ${name} library")
-    endif()
+  if(${${name}_LIBRARY_DIR} MATCHES "NOTFOUND$")
+    message(FATAL_ERROR "Can not find ${name} library")
+  endif()
 
-    find_path(${name}_INCLUDE_DIR
-        NAMES ${include}
-        HINTS "${${name}_ROOT_DIR}" "${HIP_ROOT_DIR}/../${dirname}"
-        PATH_SUFFIXES include
-        DOC "Path to ${name} include directory")
+  find_path(
+    ${name}_INCLUDE_DIR
+    NAMES ${include}
+    HINTS "${${name}_ROOT_DIR}" "${HIP_ROOT_DIR}/../${dirname}"
+    PATH_SUFFIXES include
+    DOC "Path to ${name} include directory")
 
-    if(${name}_INCLUDE_DIR MATCHES "NOTFOUND$")
-        message(FATAL_ERROR "Can not find ${name} include")
-    endif()
-    message(DEBUG "Found lib ${${name}_LIBRARY_DIR}, include ${${name}_INCLUDE_DIR}")
+  if(${name}_INCLUDE_DIR MATCHES "NOTFOUND$")
+    message(FATAL_ERROR "Can not find ${name} include")
+  endif()
+  message(DEBUG "Found lib ${${name}_LIBRARY_DIR}, include ${${name}_INCLUDE_DIR}")
 endfunction()
 
 find_rocm_library(MIOPEN miopen miopen libMIOpen.so)

cmake/tensorrt.cmake

@@ -1,166 +1,189 @@
-if("${TRT_ROOT_DIR}" STREQUAL "" AND NOT "$ENV{TRT_ROOT_DIR}"  STREQUAL "")
-    set(TRT_ROOT_DIR $ENV{TRT_ROOT_DIR})
+if("${TRT_ROOT_DIR}" STREQUAL "" AND NOT "$ENV{TRT_ROOT_DIR}" STREQUAL "")
+  set(TRT_ROOT_DIR $ENV{TRT_ROOT_DIR})
 endif()
 
 if(MGE_CUDA_USE_STATIC)
-    find_library(TRT_LIBRARY 
-        NAMES libnvinfer_static.a nvinfer.lib
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "TRT library." )
-    find_library(TRT_PLUGIN_LIBRARY
-        NAMES libnvinfer_plugin_static.a nvinfer_plugin.lib
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "TRT plugin library." )
+  find_library(
+    TRT_LIBRARY
+    NAMES libnvinfer_static.a nvinfer.lib
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "TRT library.")
+  find_library(
+    TRT_PLUGIN_LIBRARY
+    NAMES libnvinfer_plugin_static.a nvinfer_plugin.lib
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "TRT plugin library.")
 else()
-    find_library(TRT_LIBRARY 
-        NAMES libnvinfer.so libnvinfer.dylib nvinfer.dll
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "TRT library." )
-    find_library(TRT_PLUGIN_LIBRARY
-        NAMES libnvinfer_plugin.so libnvinfer_plugin.dylib nvinfer_plugin.dll
-        PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
-        HINTS ${ALTER_LIBRARY_PATHS}
-        PATH_SUFFIXES lib lib64
-        DOC "TRT plugin library." )
+  find_library(
+    TRT_LIBRARY
+    NAMES libnvinfer.so libnvinfer.dylib nvinfer.dll
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "TRT library.")
+  find_library(
+    TRT_PLUGIN_LIBRARY
+    NAMES libnvinfer_plugin.so libnvinfer_plugin.dylib nvinfer_plugin.dll
+    PATHS ${ALTER_LD_LIBRARY_PATHS} ${TRT_ROOT_DIR} ${CMAKE_INSTALL_PREFIX}
+    HINTS ${ALTER_LIBRARY_PATHS}
+    PATH_SUFFIXES lib lib64
+    DOC "TRT plugin library.")
 endif()
 
 if(TRT_LIBRARY STREQUAL "TRT_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find TensorRT Library, please refer to scripts/cmake-build/BUILD_README.md to init TRT env")
+  message(
+    FATAL_ERROR
+      "Can not find TensorRT Library, please refer to scripts/cmake-build/BUILD_README.md to init TRT env"
+  )
 endif()
 if(TRT_PLUGIN_LIBRARY STREQUAL "TRT_PLUGIN_LIBRARY-NOTFOUND")
-    message(FATAL_ERROR "Can not find TensorRT Plugin Library, please refer to scripts/cmake-build/BUILD_README.md to init TRT env")
+  message(
+    FATAL_ERROR
+      "Can not find TensorRT Plugin Library, please refer to scripts/cmake-build/BUILD_README.md to init TRT env"
+  )
 endif()
 
 get_filename_component(__found_trt_root ${TRT_LIBRARY}/../.. REALPATH)
-find_path(TRT_INCLUDE_DIR 
-    NAMES NvInfer.h
-    HINTS ${TRT_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE} ${__found_trt_root}
-    PATH_SUFFIXES include 
-    DOC "Path to TRT include directory." )
-find_path(TRT_PLUGIN_INCLUDE_DIR
-    NAMES NvInferPlugin.h
-    HINTS ${TRT_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE} ${__found_trt_root}
-    PATH_SUFFIXES include
-    DOC "Path to TRT plugin include directory." )
+find_path(
+  TRT_INCLUDE_DIR
+  NAMES NvInfer.h
+  HINTS ${TRT_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE} ${__found_trt_root}
+  PATH_SUFFIXES include
+  DOC "Path to TRT include directory.")
+find_path(
+  TRT_PLUGIN_INCLUDE_DIR
+  NAMES NvInferPlugin.h
+  HINTS ${TRT_ROOT_DIR} ${CUDA_TOOLKIT_INCLUDE} ${__found_trt_root}
+  PATH_SUFFIXES include
+  DOC "Path to TRT plugin include directory.")
 
 if(TRT_INCLUDE_DIR STREQUAL "TRT_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find TensorRT INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init TRT env")
+  message(
+    FATAL_ERROR
+      "Can not find TensorRT INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init TRT env"
+  )
 endif()
 if(TRT_PLUGIN_INCLUDE_DIR STREQUAL "TRT_PLUGIN_INCLUDE_DIR-NOTFOUND")
-    message(FATAL_ERROR "Can not find TensorRT Plugin INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init TRT env")
+  message(
+    FATAL_ERROR
+      "Can not find TensorRT Plugin INCLUDE, please refer to scripts/cmake-build/BUILD_README.md to init TRT env"
+  )
 endif()
 
-file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MAJOR REGEX "^#define NV_TENSORRT_MAJOR [0-9]+.*$")
-file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MINOR REGEX "^#define NV_TENSORRT_MINOR [0-9]+.*$")
-file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_PATCH REGEX "^#define NV_TENSORRT_PATCH [0-9]+.*$")
+file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MAJOR
+     REGEX "^#define NV_TENSORRT_MAJOR [0-9]+.*$")
+file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_MINOR
+     REGEX "^#define NV_TENSORRT_MINOR [0-9]+.*$")
+file(STRINGS "${TRT_INCLUDE_DIR}/NvInfer.h" TensorRT_PATCH
+     REGEX "^#define NV_TENSORRT_PATCH [0-9]+.*$")
 
-if (TensorRT_MAJOR STREQUAL "")
-    file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_MAJOR REGEX "^#define NV_TENSORRT_MAJOR [0-9]+.*$")
-    file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_MINOR REGEX "^#define NV_TENSORRT_MINOR [0-9]+.*$")
-    file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_PATCH REGEX "^#define NV_TENSORRT_PATCH [0-9]+.*$")
+if(TensorRT_MAJOR STREQUAL "")
+  file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_MAJOR
+       REGEX "^#define NV_TENSORRT_MAJOR [0-9]+.*$")
+  file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_MINOR
+       REGEX "^#define NV_TENSORRT_MINOR [0-9]+.*$")
+  file(STRINGS "${TRT_INCLUDE_DIR}/NvInferVersion.h" TensorRT_PATCH
+       REGEX "^#define NV_TENSORRT_PATCH [0-9]+.*$")
 endif()
 
-string(REGEX REPLACE "^#define NV_TENSORRT_MAJOR ([0-9]+).*$" "\\1" TensorRT_VERSION_MAJOR "${TensorRT_MAJOR}")
-string(REGEX REPLACE "^#define NV_TENSORRT_MINOR ([0-9]+).*$" "\\1" TensorRT_VERSION_MINOR "${TensorRT_MINOR}")
-string(REGEX REPLACE "^#define NV_TENSORRT_PATCH ([0-9]+).*$" "\\1" TensorRT_VERSION_PATCH "${TensorRT_PATCH}")
-set(TRT_VERSION_STRING "${TensorRT_VERSION_MAJOR}.${TensorRT_VERSION_MINOR}.${TensorRT_VERSION_PATCH}")
+string(REGEX REPLACE "^#define NV_TENSORRT_MAJOR ([0-9]+).*$" "\\1"
+                     TensorRT_VERSION_MAJOR "${TensorRT_MAJOR}")
+string(REGEX REPLACE "^#define NV_TENSORRT_MINOR ([0-9]+).*$" "\\1"
+                     TensorRT_VERSION_MINOR "${TensorRT_MINOR}")
+string(REGEX REPLACE "^#define NV_TENSORRT_PATCH ([0-9]+).*$" "\\1"
+                     TensorRT_VERSION_PATCH "${TensorRT_PATCH}")
+set(TRT_VERSION_STRING
+    "${TensorRT_VERSION_MAJOR}.${TensorRT_VERSION_MINOR}.${TensorRT_VERSION_PATCH}")
 
 if(MGE_CUDA_USE_STATIC)
-    add_library(libnvinfer STATIC IMPORTED)
-    add_library(libnvinfer_plugin STATIC IMPORTED)
+  add_library(libnvinfer STATIC IMPORTED)
+  add_library(libnvinfer_plugin STATIC IMPORTED)
 else()
-    add_library(libnvinfer SHARED IMPORTED)
-    add_library(libnvinfer_plugin SHARED IMPORTED)
+  add_library(libnvinfer SHARED IMPORTED)
+  add_library(libnvinfer_plugin SHARED IMPORTED)
 endif()
 
-set_target_properties(libnvinfer PROPERTIES
-    IMPORTED_LOCATION ${TRT_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${TRT_INCLUDE_DIR}
-)
-set_target_properties(libnvinfer_plugin PROPERTIES
-    IMPORTED_LOCATION ${TRT_PLUGIN_LIBRARY}
-    INTERFACE_INCLUDE_DIRECTORIES ${TRT_PLUGIN_INCLUDE_DIR}
-)
+set_target_properties(
+  libnvinfer PROPERTIES IMPORTED_LOCATION ${TRT_LIBRARY} INTERFACE_INCLUDE_DIRECTORIES
+                                                         ${TRT_INCLUDE_DIR})
+set_target_properties(
+  libnvinfer_plugin PROPERTIES IMPORTED_LOCATION ${TRT_PLUGIN_LIBRARY}
+                               INTERFACE_INCLUDE_DIRECTORIES ${TRT_PLUGIN_INCLUDE_DIR})
 
-message(STATUS "Found TensorRT: ${__found_trt_root} (found version: ${TRT_VERSION_STRING})")
+message(
+  STATUS "Found TensorRT: ${__found_trt_root} (found version: ${TRT_VERSION_STRING})")
 
 if(TensorRT_VERSION_MAJOR GREATER_EQUAL 7)
-    if(MGE_CUDA_USE_STATIC)
-        find_library(LIBMYELIN_COMPILER
-            NAMES libmyelin_compiler_static.a myelin_compiler_static.lib
-            PATHS ${__found_trt_root}/lib
-            )
-        if(LIBMYELIN_COMPILER STREQUAL "LIBMYELIN_COMPILER-NOTFOUND")
-            message(FATAL_ERROR "Can not find LIBMYELIN_COMPILER Library")
-        else()
-            message(STATUS "Found TensorRT myelin_compiler: ${LIBMYELIN_COMPILER}")
-        endif()
-        add_library(libmyelin_compiler STATIC IMPORTED)
-        set_target_properties(libmyelin_compiler PROPERTIES
-            IMPORTED_LOCATION ${LIBMYELIN_COMPILER}
-            )
+  if(MGE_CUDA_USE_STATIC)
+    find_library(
+      LIBMYELIN_COMPILER
+      NAMES libmyelin_compiler_static.a myelin_compiler_static.lib
+      PATHS ${__found_trt_root}/lib)
+    if(LIBMYELIN_COMPILER STREQUAL "LIBMYELIN_COMPILER-NOTFOUND")
+      message(FATAL_ERROR "Can not find LIBMYELIN_COMPILER Library")
+    else()
+      message(STATUS "Found TensorRT myelin_compiler: ${LIBMYELIN_COMPILER}")
+    endif()
+    add_library(libmyelin_compiler STATIC IMPORTED)
+    set_target_properties(libmyelin_compiler PROPERTIES IMPORTED_LOCATION
+                                                        ${LIBMYELIN_COMPILER})
 
-        find_library(LIBMYELIN_EXECUTOR
-            NAMES libmyelin_executor_static.a myelin_executor_static.lib
-            PATHS ${__found_trt_root}/lib
-            )
-        if(LIBMYELIN_EXECUTOR STREQUAL "LIBMYELIN_EXECUTOR-NOTFOUND")
-            message(FATAL_ERROR "Can not find LIBMYELIN_EXECUTOR Library")
-        else()
-            message(STATUS "Found TensorRT libmyelin_executor: ${LIBMYELIN_EXECUTOR}")
-        endif()
-        add_library(libmyelin_executor STATIC IMPORTED)
-        set_target_properties(libmyelin_executor PROPERTIES
-            IMPORTED_LOCATION ${LIBMYELIN_EXECUTOR}
-            )
+    find_library(
+      LIBMYELIN_EXECUTOR
+      NAMES libmyelin_executor_static.a myelin_executor_static.lib
+      PATHS ${__found_trt_root}/lib)
+    if(LIBMYELIN_EXECUTOR STREQUAL "LIBMYELIN_EXECUTOR-NOTFOUND")
+      message(FATAL_ERROR "Can not find LIBMYELIN_EXECUTOR Library")
+    else()
+      message(STATUS "Found TensorRT libmyelin_executor: ${LIBMYELIN_EXECUTOR}")
+    endif()
+    add_library(libmyelin_executor STATIC IMPORTED)
+    set_target_properties(libmyelin_executor PROPERTIES IMPORTED_LOCATION
+                                                        ${LIBMYELIN_EXECUTOR})
 
-        find_library(LIBMYELIN_PATTERN_RUNTIME
-            NAMES libmyelin_pattern_runtime_static.a myelin_pattern_runtime_static.lib
-            PATHS ${__found_trt_root}/lib
-            )
-        if(LIBMYELIN_PATTERN_RUNTIME STREQUAL "LIBMYELIN_PATTERN_RUNTIME-NOTFOUND")
-            message(FATAL_ERROR "Can not find LIBMYELIN_PATTERN_RUNTIME Library")
-        else()
-            message(STATUS "Found TensorRT libmyelin_pattern_runtime: ${LIBMYELIN_PATTERN_RUNTIME}")
-        endif()
-        add_library(libmyelin_pattern_runtime STATIC IMPORTED)
-        set_target_properties(libmyelin_pattern_runtime PROPERTIES
-            IMPORTED_LOCATION ${LIBMYELIN_PATTERN_RUNTIME}
-            )
+    find_library(
+      LIBMYELIN_PATTERN_RUNTIME
+      NAMES libmyelin_pattern_runtime_static.a myelin_pattern_runtime_static.lib
+      PATHS ${__found_trt_root}/lib)
+    if(LIBMYELIN_PATTERN_RUNTIME STREQUAL "LIBMYELIN_PATTERN_RUNTIME-NOTFOUND")
+      message(FATAL_ERROR "Can not find LIBMYELIN_PATTERN_RUNTIME Library")
+    else()
+      message(
+        STATUS "Found TensorRT libmyelin_pattern_runtime: ${LIBMYELIN_PATTERN_RUNTIME}")
+    endif()
+    add_library(libmyelin_pattern_runtime STATIC IMPORTED)
+    set_target_properties(libmyelin_pattern_runtime
+                          PROPERTIES IMPORTED_LOCATION ${LIBMYELIN_PATTERN_RUNTIME})
 
-        find_library(LIBMYELIN_PATTERN_LIBRARY
-            NAMES libmyelin_pattern_library_static.a myelin_pattern_library_static.lib
-            PATHS ${__found_trt_root}/lib
-            )
-        if(LIBMYELIN_PATTERN_LIBRARY STREQUAL "LIBMYELIN_PATTERN_LIBRARY-NOTFOUND")
-            message(FATAL_ERROR "Can not find LIBMYELIN_PATTERN_LIBRARY Library")
-        else()
-            message(STATUS "Found TensorRT libmyelin_pattern_library: ${LIBMYELIN_PATTERN_LIBRARY}")
-        endif()
-        add_library(libmyelin_pattern_library STATIC IMPORTED)
-        set_target_properties(libmyelin_pattern_library PROPERTIES
-            IMPORTED_LOCATION ${LIBMYELIN_PATTERN_LIBRARY}
-            )
+    find_library(
+      LIBMYELIN_PATTERN_LIBRARY
+      NAMES libmyelin_pattern_library_static.a myelin_pattern_library_static.lib
+      PATHS ${__found_trt_root}/lib)
+    if(LIBMYELIN_PATTERN_LIBRARY STREQUAL "LIBMYELIN_PATTERN_LIBRARY-NOTFOUND")
+      message(FATAL_ERROR "Can not find LIBMYELIN_PATTERN_LIBRARY Library")
     else()
-        find_library(LIBMYELIN_SHARED
-            NAMES libmyelin.so myelin.dll
-            PATHS ${__found_trt_root}/lib
-            )
+      message(
+        STATUS "Found TensorRT libmyelin_pattern_library: ${LIBMYELIN_PATTERN_LIBRARY}")
+    endif()
+    add_library(libmyelin_pattern_library STATIC IMPORTED)
+    set_target_properties(libmyelin_pattern_library
+                          PROPERTIES IMPORTED_LOCATION ${LIBMYELIN_PATTERN_LIBRARY})
+  else()
+    find_library(
+      LIBMYELIN_SHARED
+      NAMES libmyelin.so myelin.dll
+      PATHS ${__found_trt_root}/lib)
 
-        if(LIBMYELIN_SHARED STREQUAL "LIBMYELIN_SHARED-NOTFOUND")
-            message(FATAL_ERROR "Can not find LIBMYELIN_SHARED Library")
-        else()
-            message(STATUS "Found TensorRT libmyelin_shared: ${LIBMYELIN_SHARED}")
-        endif()
-        add_library(libmyelin SHARED IMPORTED)
-        set_target_properties(libmyelin PROPERTIES
-            IMPORTED_LOCATION ${LIBMYELIN_SHARED}
-            )
+    if(LIBMYELIN_SHARED STREQUAL "LIBMYELIN_SHARED-NOTFOUND")
+      message(FATAL_ERROR "Can not find LIBMYELIN_SHARED Library")
+    else()
+      message(STATUS "Found TensorRT libmyelin_shared: ${LIBMYELIN_SHARED}")
     endif()
+    add_library(libmyelin SHARED IMPORTED)
+    set_target_properties(libmyelin PROPERTIES IMPORTED_LOCATION ${LIBMYELIN_SHARED})
+  endif()
 endif()

cmake/zmq.cmake

@@ -1,17 +1,26 @@
 include(ExternalProject)
 include(GNUInstallDirs)
 
-set(ZMQ_DIR ${PROJECT_SOURCE_DIR}/third_party/libzmq CACHE STRING "ZMQ directory")
+set(ZMQ_DIR
+    ${PROJECT_SOURCE_DIR}/third_party/libzmq
+    CACHE STRING "ZMQ directory")
 set(ZMQ_BUILD_DIR ${PROJECT_BINARY_DIR}/third_party/libzmq)
 set(ZMQ_LIB ${ZMQ_BUILD_DIR}/${CMAKE_INSTALL_LIBDIR}/libzmq.a)
 
-ExternalProject_add(
-    zmq
-    SOURCE_DIR ${ZMQ_DIR}
-    PREFIX ${ZMQ_BUILD_DIR}
-    CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER} -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DCMAKE_INSTALL_PREFIX=${ZMQ_BUILD_DIR} -DWITH_PERF_TOOL=OFF -DZMQ_BUILD_TESTS=OFF -DENABLE_CPACK=OFF -DENABLE_CURVE=OFF
-    BUILD_BYPRODUCTS ${ZMQ_LIB}
-)
+ExternalProject_Add(
+  zmq
+  SOURCE_DIR ${ZMQ_DIR}
+  PREFIX ${ZMQ_BUILD_DIR}
+  CMAKE_ARGS -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
+             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+             -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
+             -DCMAKE_INSTALL_PREFIX=${ZMQ_BUILD_DIR}
+             -DWITH_PERF_TOOL=OFF
+             -DZMQ_BUILD_TESTS=OFF
+             -DENABLE_CPACK=OFF
+             -DENABLE_CURVE=OFF
+  BUILD_BYPRODUCTS ${ZMQ_LIB})
 
 set(ZMQ_INC ${ZMQ_BUILD_DIR}/include)
 include_directories(${ZMQ_INC})
@@ -19,8 +28,5 @@ file(MAKE_DIRECTORY ${ZMQ_INC})
 
 add_library(libzmq STATIC IMPORTED GLOBAL)
 add_dependencies(libzmq zmq)
-set_target_properties(
-    libzmq PROPERTIES
-    IMPORTED_LOCATION ${ZMQ_LIB}
-    INTERFACE_INCLUDE_DIRECTORIES ${ZMQ_INC}
-)
+set_target_properties(libzmq PROPERTIES IMPORTED_LOCATION ${ZMQ_LIB}
+                                        INTERFACE_INCLUDE_DIRECTORIES ${ZMQ_INC})

dnn/CMakeLists.txt

@@ -4,66 +4,61 @@ set(OPR_PARAM_DEFS_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_param_defs.py)
 set(OPR_PARAM_DEFS_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/include/)
 file(MAKE_DIRECTORY ${OPR_PARAM_DEFS_OUT_DIR}/megdnn)
 add_custom_command(
-    OUTPUT
-        ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
-        ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_json.h
-        COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT} ${OPR_PARAM_DEFS_SRCS}
-        ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
-        COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT} ${OPR_PARAM_DEFS_SRCS}
-       tmp_unuse.log --write-cppjson ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_json.h
-    DEPENDS ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_SCRIPT}
-    VERBATIM
-)
-
-list(APPEND OPR_PARAM_DEFS_OUTS
-    ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
+  OUTPUT ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
+         ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_json.h
+  COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT}
+          ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
+  COMMAND
+    ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT}
+    ${OPR_PARAM_DEFS_SRCS} tmp_unuse.log --write-cppjson
     ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_json.h
-)
+  DEPENDS ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_SCRIPT}
+  VERBATIM)
+
+list(APPEND OPR_PARAM_DEFS_OUTS ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_defs.h
+     ${OPR_PARAM_DEFS_OUT_DIR}/megdnn/opr_param_json.h)
 list(APPEND OPR_PARAM_DEFS_INC ${OPR_PARAM_DEFS_OUT_DIR})
 
 set(OPR_PARAM_DEFS_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
 file(MAKE_DIRECTORY ${OPR_PARAM_DEFS_OUT_DIR}/src/common)
 add_custom_command(
-    OUTPUT
-        ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh
-        COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT}
-        --enumv ${OPR_PARAM_DEFS_SRCS}
-        ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh
-    DEPENDS ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_SCRIPT}
-    VERBATIM
-)
+  OUTPUT ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh
+  COMMAND
+    ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${OPR_PARAM_DEFS_SCRIPT} --enumv
+    ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh
+  DEPENDS ${OPR_PARAM_DEFS_SRCS} ${OPR_PARAM_DEFS_SCRIPT}
+  VERBATIM)
 
 list(APPEND OPR_PARAM_DEFS_OUTS
-    ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh
-)
+     ${OPR_PARAM_DEFS_OUT_DIR}/src/common/opr_param_defs_enumv.cuh)
 list(APPEND OPR_PARAM_DEFS_INC ${OPR_PARAM_DEFS_OUT_DIR})
 
-install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/megdnn DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
+install(
+  DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/megdnn
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+  FILES_MATCHING
+  PATTERN "*.h")
 
 add_custom_target(_opr_param_defs DEPENDS ${OPR_PARAM_DEFS_OUTS})
 add_library(opr_param_defs INTERFACE)
 target_include_directories(opr_param_defs
-    INTERFACE
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-foreach (INCPATH IN LISTS OPR_PARAM_DEFS_INC)
-    target_include_directories(opr_param_defs
-        INTERFACE $<BUILD_INTERFACE:${INCPATH}>
-    )
+                           INTERFACE $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+foreach(INCPATH IN LISTS OPR_PARAM_DEFS_INC)
+  target_include_directories(opr_param_defs INTERFACE $<BUILD_INTERFACE:${INCPATH}>)
 endforeach()
 
 add_dependencies(opr_param_defs _opr_param_defs)
 install(TARGETS opr_param_defs EXPORT ${MGE_EXPORT_TARGETS})
 
 if(MGE_WITH_CUDA)
-    add_library(cutlass INTERFACE)
-    target_include_directories(cutlass 
-        INTERFACE 
-        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cutlass/include>)
+  add_library(cutlass INTERFACE)
+  target_include_directories(
+    cutlass
+    INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cutlass/include>)
 endif()
 
 if(MGE_WITH_TEST)
-    add_subdirectory(test)
+  add_subdirectory(test)
 endif()
 
 add_subdirectory(src)

dnn/atlas-stub/CMakeLists.txt

@@ -1,6 +1,8 @@
 add_library(atlas-stub STATIC src/libatlas-wrap.cpp)
-target_include_directories(atlas-stub PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+target_include_directories(
+  atlas-stub PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
 install(TARGETS atlas-stub EXPORT ${MGE_EXPORT_TARGETS})
 
 add_library(acl-cblas STATIC src/libacl_cblas-wrap.cpp)
-target_include_directories(acl-cblas PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
+target_include_directories(
+  acl-cblas PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)

dnn/cuda-stub/CMakeLists.txt

@@ -1,26 +1,27 @@
-file (GLOB_RECURSE CUDA_STUB src/libcuda.cpp)
-file (GLOB_RECURSE NVRTC_STUB src/libnvrtc.cpp)
+file(GLOB_RECURSE CUDA_STUB src/libcuda.cpp)
+file(GLOB_RECURSE NVRTC_STUB src/libnvrtc.cpp)
 
 if(MGE_WITH_CUDA_STUB)
-    list(APPEND STUB_SRC ${CUDA_STUB})
+  list(APPEND STUB_SRC ${CUDA_STUB})
 endif()
 
 if(MGE_WITH_NVRTC_STUB)
-    list(APPEND STUB_SRC ${NVRTC_STUB})
+  list(APPEND STUB_SRC ${NVRTC_STUB})
 endif()
 
 if(MSVC OR WIN32)
-    add_library (cuda-stub STATIC ${STUB_SRC})
+  add_library(cuda-stub STATIC ${STUB_SRC})
 else()
-    add_library (cuda-stub SHARED ${STUB_SRC})
+  add_library(cuda-stub SHARED ${STUB_SRC})
 endif()
 
 set_target_properties(cuda-stub PROPERTIES OUTPUT_NAME cuda_stub)
 target_compile_definitions(cuda-stub PRIVATE __CUDA_API_VERSION_INTERNAL)
-if (MSVC OR WIN32)
-    target_link_libraries(cuda-stub PRIVATE -Wl,--no-undefined)
+if(MSVC OR WIN32)
+  target_link_libraries(cuda-stub PRIVATE -Wl,--no-undefined)
 else()
-    target_link_libraries(cuda-stub PRIVATE dl -Wl,--no-undefined)
+  target_link_libraries(cuda-stub PRIVATE dl -Wl,--no-undefined)
 endif()
-target_include_directories(cuda-stub PRIVATE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/genfiles>)
-install (TARGETS cuda-stub EXPORT ${MGE_EXPORT_TARGETS})
+target_include_directories(cuda-stub
+                           PRIVATE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/genfiles>)
+install(TARGETS cuda-stub EXPORT ${MGE_EXPORT_TARGETS})

dnn/src/CMakeLists.txt

@@ -5,168 +5,190 @@ file(GLOB_RECURSE SOURCES common/*.cpp naive/*.cpp)
 list(APPEND SOURCES ${PROJECT_BINARY_DIR}/genfiles/megbrain_build_config.h)
 
 if(NOT ${MGE_ARCH} STREQUAL "naive")
-    file(GLOB_RECURSE SOURCES_ fallback/*.cpp)
+  file(GLOB_RECURSE SOURCES_ fallback/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
+  if(${MGE_ARCH} STREQUAL "fallback")
+    message(WARNING "build only with fallback")
+  elseif(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386")
+    file(GLOB_RECURSE SOURCES_ x86/*.cpp)
     list(APPEND SOURCES ${SOURCES_})
-    if(${MGE_ARCH} STREQUAL "fallback")
-        message(WARNING "build only with fallback")
-    elseif(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386")
-        file(GLOB_RECURSE SOURCES_ x86/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-        if(NOT MSVC)
-            file(GLOB_RECURSE SOURCES_ x86/*.S)
-            set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
-            list(APPEND SOURCES ${SOURCES_})
-        endif()
-    elseif(${MGE_ARCH} STREQUAL "armv7")
-        file(GLOB_RECURSE SOURCES_ armv7/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-        file(GLOB_RECURSE SOURCES_ arm_common/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-        file(GLOB_RECURSE SOURCES_ armv7/*.S)
-        set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
-        list(APPEND SOURCES ${SOURCES_})
-    elseif(${MGE_ARCH} STREQUAL "aarch64")
-        file(GLOB_RECURSE SOURCES_ aarch64/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-        file(GLOB_RECURSE SOURCES_ arm_common/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-        file(GLOB_RECURSE SOURCES_ aarch64/*.S)
-        set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
-        list(APPEND SOURCES ${SOURCES_})
+    if(NOT MSVC)
+      file(GLOB_RECURSE SOURCES_ x86/*.S)
+      set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
+      list(APPEND SOURCES ${SOURCES_})
     endif()
+  elseif(${MGE_ARCH} STREQUAL "armv7")
+    file(GLOB_RECURSE SOURCES_ armv7/*.cpp)
+    list(APPEND SOURCES ${SOURCES_})
+    file(GLOB_RECURSE SOURCES_ arm_common/*.cpp)
+    list(APPEND SOURCES ${SOURCES_})
+    file(GLOB_RECURSE SOURCES_ armv7/*.S)
+    set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
+    list(APPEND SOURCES ${SOURCES_})
+  elseif(${MGE_ARCH} STREQUAL "aarch64")
+    file(GLOB_RECURSE SOURCES_ aarch64/*.cpp)
+    list(APPEND SOURCES ${SOURCES_})
+    file(GLOB_RECURSE SOURCES_ arm_common/*.cpp)
+    list(APPEND SOURCES ${SOURCES_})
+    file(GLOB_RECURSE SOURCES_ aarch64/*.S)
+    set_source_files_properties(${SOURCES_} PROPERTIES LANGUAGE C)
+    list(APPEND SOURCES ${SOURCES_})
+  endif()
 endif()
 
 if(MGE_WITH_MIDOUT_PROFILE)
-    list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/third_party/midout/src/midout.cpp)
+  list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/third_party/midout/src/midout.cpp)
 endif()
 
-###############################################################################
+# ######################################################################################
 # HIP_COMPILE
-###############################################################################
-macro (HIP_COMPILE _hip_target _hip_objs)
-    # Separate the sources from the options
-    HIP_GET_SOURCES_AND_OPTIONS(_sources
-        _cmake_options
-        _hipcc_options
-        _hcc_options
-        _nvcc_options
-        ${ARGN})
-    HIP_PREPARE_TARGET_COMMANDS(${_hip_target}
-        OBJ _generated_files _source_files ${_sources} ${_cmake_options}
-        HIPCC_OPTIONS ${_hipcc_options}
-        HCC_OPTIONS ${_hcc_options}
-        NVCC_OPTIONS ${_nvcc_options})
-    if(_source_files)
-        list(REMOVE_ITEM _sources ${_source_files})
-    endif()
+# ######################################################################################
+macro(HIP_COMPILE _hip_target _hip_objs)
+  # Separate the sources from the options
+  hip_get_sources_and_options(_sources _cmake_options _hipcc_options _hcc_options
+                              _nvcc_options ${ARGN})
+  hip_prepare_target_commands(
+    ${_hip_target}
+    OBJ
+    _generated_files
+    _source_files
+    ${_sources}
+    ${_cmake_options}
+    HIPCC_OPTIONS
+    ${_hipcc_options}
+    HCC_OPTIONS
+    ${_hcc_options}
+    NVCC_OPTIONS
+    ${_nvcc_options})
+  if(_source_files)
+    list(REMOVE_ITEM _sources ${_source_files})
+  endif()
 
-    add_custom_target(${_hip_target})
+  add_custom_target(${_hip_target})
 
-    # set return value
-    set(${_hip_objs} ${_generated_files})
+  # set return value
+  set(${_hip_objs} ${_generated_files})
 endmacro()
 
-if (MGE_WITH_ROCM)
-    file (GLOB_RECURSE SOURCES_ rocm/*.cpp)
-    list (APPEND SOURCES ${SOURCES_})
-
-    # FIXME rocm may lost the first hip file, so currently we just create an
-    # empty file to bypass this error.
-    file(GLOB start.cpp.hip "" )
-    list(APPEND HIP_SOURCES start.cpp.hip)
-    configure_file(
-        ${PROJECT_SOURCE_DIR}/dnn/include/hcc_detail/hcc_defs_prologue.h.in
-        ${PROJECT_BINARY_DIR}/dnn/include/hcc_detail/hcc_defs_prologue.h)
-
-    configure_file(
-        ${PROJECT_SOURCE_DIR}/dnn/include/hcc_detail/hcc_defs_epilogue.h.in
-        ${PROJECT_BINARY_DIR}/dnn/include/hcc_detail/hcc_defs_epilogue.h)
-
-    file(GLOB_RECURSE HIP_SOURCES_ rocm/*.cpp.hip)
-    set(HIP_TARGET_NAME megdnn_hip_kernel)
-    set(_HIPCC_OPTIONS "-fPIC")
-    set(_HCC_OPTIONS "-fPIC")
-    set(_NVCC_OPTIONS "-fPIC")
-
-    list(APPEND HIP_SOURCES ${HIP_SOURCES_})
-    set_source_files_properties(${HIP_SOURCES} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
-    HIP_INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/dnn
-        ${PROJECT_SOURCE_DIR}/dnn/include
-        ${PROJECT_BINARY_DIR}/dnn
-        ${PROJECT_BINARY_DIR}/genfiles
-        ${PROJECT_BINARY_DIR}/dnn/include
-        ${HIP_INCLUDE_DIR}
-        ${MIOPEN_INCLUDE_DIR}
-        ${ROCBLAS_INCLUDE_DIR}
-        ${ROCRAND_INCLUDE_DIR}
-        ${AMDOCL_INCLUDE_DIR})
-    hip_compile(
-        ${HIP_TARGET_NAME} HIPOBJS ${HIP_SOURCES}
-        HIPCC_OPTIONS ${_HIPCC_OPTIONS}
-        HCC_OPTIONS ${_HCC_OPTIONS}
-        NVCC_OPTIONS ${_NVCC_OPTIONS})
-    list(APPEND SOURCES ${HIPOBJS})
-endif ()
+if(MGE_WITH_ROCM)
+  file(GLOB_RECURSE SOURCES_ rocm/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
+
+  # FIXME rocm may lost the first hip file, so currently we just create an empty file to
+  # bypass this error.
+  file(GLOB start.cpp.hip "")
+  list(APPEND HIP_SOURCES start.cpp.hip)
+  configure_file(${PROJECT_SOURCE_DIR}/dnn/include/hcc_detail/hcc_defs_prologue.h.in
+                 ${PROJECT_BINARY_DIR}/dnn/include/hcc_detail/hcc_defs_prologue.h)
+
+  configure_file(${PROJECT_SOURCE_DIR}/dnn/include/hcc_detail/hcc_defs_epilogue.h.in
+                 ${PROJECT_BINARY_DIR}/dnn/include/hcc_detail/hcc_defs_epilogue.h)
+
+  file(GLOB_RECURSE HIP_SOURCES_ rocm/*.cpp.hip)
+  set(HIP_TARGET_NAME megdnn_hip_kernel)
+  set(_HIPCC_OPTIONS "-fPIC")
+  set(_HCC_OPTIONS "-fPIC")
+  set(_NVCC_OPTIONS "-fPIC")
+
+  list(APPEND HIP_SOURCES ${HIP_SOURCES_})
+  set_source_files_properties(${HIP_SOURCES} PROPERTIES HIP_SOURCE_PROPERTY_FORMAT 1)
+  hip_include_directories(
+    ${PROJECT_SOURCE_DIR}/dnn
+    ${PROJECT_SOURCE_DIR}/dnn/include
+    ${PROJECT_BINARY_DIR}/dnn
+    ${PROJECT_BINARY_DIR}/genfiles
+    ${PROJECT_BINARY_DIR}/dnn/include
+    ${HIP_INCLUDE_DIR}
+    ${MIOPEN_INCLUDE_DIR}
+    ${ROCBLAS_INCLUDE_DIR}
+    ${ROCRAND_INCLUDE_DIR}
+    ${AMDOCL_INCLUDE_DIR})
+  hip_compile(
+    ${HIP_TARGET_NAME}
+    HIPOBJS
+    ${HIP_SOURCES}
+    HIPCC_OPTIONS
+    ${_HIPCC_OPTIONS}
+    HCC_OPTIONS
+    ${_HCC_OPTIONS}
+    NVCC_OPTIONS
+    ${_NVCC_OPTIONS})
+  list(APPEND SOURCES ${HIPOBJS})
+endif()
 
 if(MGE_WITH_CUDA)
-    file(GLOB_RECURSE SOURCES_ cuda/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ cuda/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 
-    file(GLOB_RECURSE CUSOURCES cuda/*.cu)
-
-    set(CUTLASS_GEN_SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/../scripts/cutlass_generator/generator.py)
-    set(CUTLASS_GEN_DIR ${CMAKE_CURRENT_BINARY_DIR}/cuda/cutlass/generated)
-    set(CUTLASS_SOURCES "")
-    function(gen_cutlass_kimpl op type gen_files)
-        set(CURRENT_CUTLASS_STAGE_DIR ${CUTLASS_GEN_DIR}/${op}_${type}.stage)
-        set(CURRENT_CUTLASS_GEN_DIR ${CUTLASS_GEN_DIR}/${op}_${type})
-        
-        set_directory_properties(PROPERTIES CMAKE_CONFIGURE_DEPENDS ${CUTLASS_GEN_SCRIPT})
-        
-        file(REMOVE_RECURSE ${CURRENT_CUTLASS_STAGE_DIR})
-        file(MAKE_DIRECTORY ${CURRENT_CUTLASS_STAGE_DIR})
-        file(MAKE_DIRECTORY ${CURRENT_CUTLASS_GEN_DIR})
-        execute_process(
-            COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${CUTLASS_GEN_SCRIPT} --operations ${op} --type ${type} ${CURRENT_CUTLASS_STAGE_DIR}
-            RESULT_VARIABLE gen_cutlass_result
-            OUTPUT_FILE ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log
-            ERROR_FILE ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log
-        )
-        if (NOT gen_cutlass_result EQUAL 0)
-            message(FATAL_ERROR "Error generating library instances. See ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log")
-        endif()
-        file(GLOB CUTLASS_GEN_FILES RELATIVE "${CURRENT_CUTLASS_GEN_DIR}/" "${CURRENT_CUTLASS_GEN_DIR}/*.cu")
-        foreach(FILE ${CUTLASS_GEN_FILES}) 
-            if (NOT EXISTS "${CURRENT_CUTLASS_STAGE_DIR}/${FILE}")
-                file(REMOVE "${CURRENT_CUTLASS_GEN_DIR}/${FILE}")
-            endif()
-        endforeach()
-        file(GLOB CUTLASS_GEN_FILES RELATIVE "${CURRENT_CUTLASS_STAGE_DIR}" "${CURRENT_CUTLASS_STAGE_DIR}/*.cu")
-        foreach(FILE ${CUTLASS_GEN_FILES})
-            execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CURRENT_CUTLASS_STAGE_DIR}/${FILE}" "${CURRENT_CUTLASS_GEN_DIR}")
-        endforeach()
-        file(REMOVE_RECURSE ${CURRENT_CUTLASS_STAGE_DIR})
-        file(GLOB_RECURSE CUTLASS_GEN_FILES "${CURRENT_CUTLASS_GEN_DIR}/*.cu")
-        list(APPEND ${gen_files} ${CUTLASS_GEN_FILES})
-        set(${gen_files} "${${gen_files}}" PARENT_SCOPE)
-    endfunction()
-    gen_cutlass_kimpl(gemm simt CUTLASS_SOURCES)
-    gen_cutlass_kimpl(gemm tensorop884 CUTLASS_SOURCES)
-    gen_cutlass_kimpl(gemm tensorop1688 CUTLASS_SOURCES)
-    gen_cutlass_kimpl(gemv simt CUTLASS_SOURCES)
-    gen_cutlass_kimpl(deconv simt CUTLASS_SOURCES)
-    gen_cutlass_kimpl(deconv tensorop8816 CUTLASS_SOURCES)
-    gen_cutlass_kimpl(conv2d simt CUTLASS_SOURCES)
-    gen_cutlass_kimpl(conv2d tensorop8816 CUTLASS_SOURCES)
-    gen_cutlass_kimpl(conv2d tensorop8832 CUTLASS_SOURCES)
-    list(APPEND SOURCES ${CUTLASS_SOURCES})
-    list(APPEND SOURCES ${CUSOURCES})
+  file(GLOB_RECURSE CUSOURCES cuda/*.cu)
+
+  set(CUTLASS_GEN_SCRIPT
+      ${CMAKE_CURRENT_SOURCE_DIR}/../scripts/cutlass_generator/generator.py)
+  set(CUTLASS_GEN_DIR ${CMAKE_CURRENT_BINARY_DIR}/cuda/cutlass/generated)
+  set(CUTLASS_SOURCES "")
+  function(gen_cutlass_kimpl op type gen_files)
+    set(CURRENT_CUTLASS_STAGE_DIR ${CUTLASS_GEN_DIR}/${op}_${type}.stage)
+    set(CURRENT_CUTLASS_GEN_DIR ${CUTLASS_GEN_DIR}/${op}_${type})
+
+    set_directory_properties(PROPERTIES CMAKE_CONFIGURE_DEPENDS ${CUTLASS_GEN_SCRIPT})
+
+    file(REMOVE_RECURSE ${CURRENT_CUTLASS_STAGE_DIR})
+    file(MAKE_DIRECTORY ${CURRENT_CUTLASS_STAGE_DIR})
+    file(MAKE_DIRECTORY ${CURRENT_CUTLASS_GEN_DIR})
+    execute_process(
+      COMMAND ${PYTHON3_EXECUTABLE_WITHOUT_VERSION} ${CUTLASS_GEN_SCRIPT} --operations
+              ${op} --type ${type} ${CURRENT_CUTLASS_STAGE_DIR}
+      RESULT_VARIABLE gen_cutlass_result
+      OUTPUT_FILE ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log
+      ERROR_FILE ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log)
+    if(NOT gen_cutlass_result EQUAL 0)
+      message(
+        FATAL_ERROR
+          "Error generating library instances. See ${CURRENT_CUTLASS_GEN_DIR}/gen_cutlass.log"
+      )
+    endif()
+    file(
+      GLOB CUTLASS_GEN_FILES
+      RELATIVE "${CURRENT_CUTLASS_GEN_DIR}/"
+      "${CURRENT_CUTLASS_GEN_DIR}/*.cu")
+    foreach(FILE ${CUTLASS_GEN_FILES})
+      if(NOT EXISTS "${CURRENT_CUTLASS_STAGE_DIR}/${FILE}")
+        file(REMOVE "${CURRENT_CUTLASS_GEN_DIR}/${FILE}")
+      endif()
+    endforeach()
+    file(
+      GLOB CUTLASS_GEN_FILES
+      RELATIVE "${CURRENT_CUTLASS_STAGE_DIR}"
+      "${CURRENT_CUTLASS_STAGE_DIR}/*.cu")
+    foreach(FILE ${CUTLASS_GEN_FILES})
+      execute_process(
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "${CURRENT_CUTLASS_STAGE_DIR}/${FILE}" "${CURRENT_CUTLASS_GEN_DIR}")
+    endforeach()
+    file(REMOVE_RECURSE ${CURRENT_CUTLASS_STAGE_DIR})
+    file(GLOB_RECURSE CUTLASS_GEN_FILES "${CURRENT_CUTLASS_GEN_DIR}/*.cu")
+    list(APPEND ${gen_files} ${CUTLASS_GEN_FILES})
+    set(${gen_files}
+        "${${gen_files}}"
+        PARENT_SCOPE)
+  endfunction()
+  gen_cutlass_kimpl(gemm simt CUTLASS_SOURCES)
+  gen_cutlass_kimpl(gemm tensorop884 CUTLASS_SOURCES)
+  gen_cutlass_kimpl(gemm tensorop1688 CUTLASS_SOURCES)
+  gen_cutlass_kimpl(gemv simt CUTLASS_SOURCES)
+  gen_cutlass_kimpl(deconv simt CUTLASS_SOURCES)
+  gen_cutlass_kimpl(deconv tensorop8816 CUTLASS_SOURCES)
+  gen_cutlass_kimpl(conv2d simt CUTLASS_SOURCES)
+  gen_cutlass_kimpl(conv2d tensorop8816 CUTLASS_SOURCES)
+  gen_cutlass_kimpl(conv2d tensorop8832 CUTLASS_SOURCES)
+  list(APPEND SOURCES ${CUTLASS_SOURCES})
+  list(APPEND SOURCES ${CUSOURCES})
 endif()
 
 if(MGE_WITH_ATLAS)
-    file(GLOB_RECURSE SOURCES_ atlas/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
-    list(APPEND LIBMEGDNN_DEF -DMEGDNN_WITH_ATLAS=1)
+  file(GLOB_RECURSE SOURCES_ atlas/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
+  list(APPEND LIBMEGDNN_DEF -DMEGDNN_WITH_ATLAS=1)
 endif()
 
 add_definitions(${LIBMEGDNN_DEF})
@@ -174,81 +196,85 @@ add_library(megdnn EXCLUDE_FROM_ALL OBJECT ${SOURCES})
 
 target_link_libraries(megdnn PUBLIC opr_param_defs)
 if(MGE_WITH_CUDA)
-    target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:cutlass>)
-    target_include_directories(megdnn PRIVATE ${CUDNN_INCLUDE_DIR})
+  target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:cutlass>)
+  target_include_directories(megdnn PRIVATE ${CUDNN_INCLUDE_DIR})
 endif()
 
 if(MGE_WITH_ROCM)
-    target_include_directories(megdnn PUBLIC
-        ${HIP_INCLUDE_DIR}
-        ${MIOPEN_INCLUDE_DIR}
-        ${ROCBLAS_INCLUDE_DIR}
-        ${ROCRAND_INCLUDE_DIR}
-        ${AMDOCL_INCLUDE_DIR})
-    target_link_directories(megdnn PUBLIC
-        ${HIP_LIBRARY_DIR}
-        ${MIOPEN_LIBRARY_DIR}
-        ${ROCBLAS_LIBRARY_DIR}
-        ${ROCRAND_LIBRARY_DIR}
-        ${AMDOCL_LIBRARY_DIR})
+  target_include_directories(
+    megdnn PUBLIC ${HIP_INCLUDE_DIR} ${MIOPEN_INCLUDE_DIR} ${ROCBLAS_INCLUDE_DIR}
+                  ${ROCRAND_INCLUDE_DIR} ${AMDOCL_INCLUDE_DIR})
+  target_link_directories(
+    megdnn
+    PUBLIC
+    ${HIP_LIBRARY_DIR}
+    ${MIOPEN_LIBRARY_DIR}
+    ${ROCBLAS_LIBRARY_DIR}
+    ${ROCRAND_LIBRARY_DIR}
+    ${AMDOCL_LIBRARY_DIR})
 endif()
 
-if(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386" OR ${MGE_ARCH} STREQUAL "armv7" OR ${MGE_ARCH} STREQUAL "aarch64")
-    if(MGE_ENABLE_CPUINFO)
-        target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:cpuinfo>)
-    endif()
+if(${MGE_ARCH} STREQUAL "x86_64"
+   OR ${MGE_ARCH} STREQUAL "i386"
+   OR ${MGE_ARCH} STREQUAL "armv7"
+   OR ${MGE_ARCH} STREQUAL "aarch64")
+  if(MGE_ENABLE_CPUINFO)
+    target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:cpuinfo>)
+  endif()
 endif()
 
-target_include_directories(megdnn
-    PUBLIC
-        $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/genfiles>
-        $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/dnn/include>
-        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    PRIVATE
-        ${PROJECT_SOURCE_DIR}/dnn
-        ${PROJECT_SOURCE_DIR}/third_party/midout/src
-)
+target_include_directories(
+  megdnn
+  PUBLIC $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/genfiles>
+         $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/dnn/include>
+         $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE ${PROJECT_SOURCE_DIR}/dnn ${PROJECT_SOURCE_DIR}/third_party/midout/src)
 
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/dnn/include DESTINATION . FILES_MATCHING PATTERN "*.h*")
+install(
+  DIRECTORY ${PROJECT_SOURCE_DIR}/dnn/include
+  DESTINATION .
+  FILES_MATCHING
+  PATTERN "*.h*")
 
 if(CXX_SUPPORT_WCLASS_MEMACCESS)
-    if(MGE_WITH_CUDA)
-        target_compile_options(megdnn PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
-            "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
-    else()
-        target_compile_options(megdnn PRIVATE "-Wno-class-memaccess")
-    endif()
+  if(MGE_WITH_CUDA)
+    target_compile_options(
+      megdnn PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
+                     "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
+  else()
+    target_compile_options(megdnn PRIVATE "-Wno-class-memaccess")
+  endif()
 endif()
 target_compile_definitions(megdnn INTERFACE ${LIBMEGDNN_DEF})
 
 if(MGE_WITH_MKLDNN AND ${MGE_ARCH} STREQUAL "x86_64")
-    if (BUILD_SHARED_LIBS)
-        target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:dnnl>)
-    else()
-        target_link_libraries(megdnn PRIVATE dnnl)
-    endif()
+  if(BUILD_SHARED_LIBS)
+    target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:dnnl>)
+  else()
+    target_link_libraries(megdnn PRIVATE dnnl)
+  endif()
 endif()
-if (BUILD_SHARED_LIBS)
-    target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:${MGE_BLAS_LIBS}>)
+if(BUILD_SHARED_LIBS)
+  target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:${MGE_BLAS_LIBS}>)
 else()
-    target_link_libraries(megdnn PRIVATE ${MGE_BLAS_LIBS})
+  target_link_libraries(megdnn PRIVATE ${MGE_BLAS_LIBS})
 endif()
 
-if (MGE_WITH_ROCM)
-    target_link_libraries(megdnn PRIVATE ${HIPOBJS} ${MGE_ROCM_LIBS})
-endif ()
+if(MGE_WITH_ROCM)
+  target_link_libraries(megdnn PRIVATE ${HIPOBJS} ${MGE_ROCM_LIBS})
+endif()
 
 if(MGE_WITH_ATLAS)
-    if (BUILD_SHARED_LIBS)
-        target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:${MGE_ATLAS_LIBS}>)
-    else()
-        target_link_libraries(megdnn PRIVATE ${MGE_ATLAS_LIBS})
-    endif()
+  if(BUILD_SHARED_LIBS)
+    target_link_libraries(megdnn PRIVATE $<BUILD_INTERFACE:${MGE_ATLAS_LIBS}>)
+  else()
+    target_link_libraries(megdnn PRIVATE ${MGE_ATLAS_LIBS})
+  endif()
 
 endif()
 
 if(CMAKE_THREAD_LIBS_INIT)
-    target_link_libraries(megdnn PRIVATE Threads::Threads)
+  target_link_libraries(megdnn PRIVATE Threads::Threads)
 endif()
 
 install(TARGETS megdnn EXPORT ${MGE_EXPORT_TARGETS})

dnn/test/CMakeLists.txt

@@ -5,38 +5,38 @@ file(GLOB SOURCES_ *.cpp)
 list(APPEND SOURCES ${SOURCES_})
 
 if(NOT ${MGE_ARCH} STREQUAL "naive")
-    file(GLOB_RECURSE SOURCES_ fallback/*.cpp)
+  file(GLOB_RECURSE SOURCES_ fallback/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ cpu/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
+  if(${MGE_ARCH} STREQUAL "fallback")
+    message(WARNING "build only with fallback")
+  elseif(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386")
+    file(GLOB_RECURSE SOURCES_ x86/*.cpp)
     list(APPEND SOURCES ${SOURCES_})
-    file(GLOB_RECURSE SOURCES_ cpu/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
-    if(${MGE_ARCH} STREQUAL "fallback")
-        message(WARNING "build only with fallback")
-    elseif(${MGE_ARCH} STREQUAL "x86_64" OR ${MGE_ARCH} STREQUAL "i386")
-        file(GLOB_RECURSE SOURCES_ x86/*.cpp)
-        list(APPEND SOURCES ${SOURCES_})
-    endif()
+  endif()
 endif()
 
 if(MGE_WITH_CUDA)
-    file(GLOB_RECURSE SOURCES_ cuda/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ cuda/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 
-    file(GLOB_RECURSE CUSOURCES cuda/*.cu)
-    list(APPEND SOURCES ${CUSOURCES})
+  file(GLOB_RECURSE CUSOURCES cuda/*.cu)
+  list(APPEND SOURCES ${CUSOURCES})
 endif()
 
 if(MGE_WITH_MIDOUT_PROFILE)
-    list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/third_party/midout/src/midout.cpp)
+  list(APPEND SOURCES ${PROJECT_SOURCE_DIR}/third_party/midout/src/midout.cpp)
 endif()
 
 if(MGE_WITH_ATLAS)
-    file(GLOB_RECURSE SOURCES_ atlas/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ atlas/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
-if (MGE_WITH_ROCM)
-    file (GLOB_RECURSE SOURCES_ rocm/*.cpp)
-    list (APPEND SOURCES ${SOURCES_})
+if(MGE_WITH_ROCM)
+  file(GLOB_RECURSE SOURCES_ rocm/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 add_executable(megdnn_test ${SOURCES})
@@ -44,37 +44,36 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-narrowing")
 target_link_libraries(megdnn_test gtest)
 target_link_libraries(megdnn_test megdnn ${MGE_BLAS_LIBS} ${MGE_CUDA_LIBS})
 
-if (MGE_WITH_CUDA)
-    target_link_libraries(megdnn_test cutlass)
-    target_include_directories(megdnn_test PRIVATE ${CUDNN_INCLUDE_DIR})
+if(MGE_WITH_CUDA)
+  target_link_libraries(megdnn_test cutlass)
+  target_include_directories(megdnn_test PRIVATE ${CUDNN_INCLUDE_DIR})
 endif()
 if(MGE_WITH_ATLAS)
-    target_link_libraries(megdnn_test atlas-stub)
+  target_link_libraries(megdnn_test atlas-stub)
 endif()
 
 target_include_directories(megdnn_test
-    PRIVATE
-        ${PROJECT_SOURCE_DIR}/third_party/midout/src
-)
+                           PRIVATE ${PROJECT_SOURCE_DIR}/third_party/midout/src)
 
 if(APPLE OR ANDROID)
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
 else()
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
+  set(CMAKE_EXE_LINKER_FLAGS
+      "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
 endif()
 
 if(MGE_ENABLE_COVERAGE)
-    set(CMAKE_EXE_LINKER_FLAGS  "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
 endif()
 
-if (MEG_WITH_ROCM)
-    target_link_libraries (megdnn_test ${MGE_ROCM_LIBS})
-endif ()
+if(MEG_WITH_ROCM)
+  target_link_libraries(megdnn_test ${MGE_ROCM_LIBS})
+endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(megdnn_test dl)
-    else()
-        target_link_libraries(megdnn_test dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(megdnn_test dl)
+  else()
+    target_link_libraries(megdnn_test dl rt)
+  endif()
 endif()

imperative/CMakeLists.txt

@@ -1,21 +1,28 @@
 find_package(NumPy REQUIRED)
 
 set(PACKAGE_NAME megengine)
-set(PACKAGE_NAME ${PACKAGE_NAME} PARENT_SCOPE)
+set(PACKAGE_NAME
+    ${PACKAGE_NAME}
+    PARENT_SCOPE)
 set(MODULE_NAME _imperative_rt)
-set(MODULE_NAME ${MODULE_NAME} PARENT_SCOPE)
+set(MODULE_NAME
+    ${MODULE_NAME}
+    PARENT_SCOPE)
 file(GLOB_RECURSE SRCS src/impl/*.cpp src/include/*.h python/src/*.cpp python/src/*.h)
 set(SRCS ${SRCS} ${CPP_REDIS_SRCS})
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMGB_WITH_IMPERATIVE=1")
 
 file(GLOB_RECURSE PYTHON_SRCS python/${PACKAGE_NAME}/*.py)
-file(GLOB_RECURSE ALL_HEADERS src/cpp/megbrain_pubapi.h
-    ${PROJECT_SOURCE_DIR}/src/core/include/*
-    ${PROJECT_SOURCE_DIR}/src/opr/include/*
-    ${PROJECT_SOURCE_DIR}/src/serialization/include/*
-    ${PROJECT_SOURCE_DIR}/src/plugin/include/*
-    ${PROJECT_SOURCE_DIR}/dnn/include/*)
+file(
+  GLOB_RECURSE
+  ALL_HEADERS
+  src/cpp/megbrain_pubapi.h
+  ${PROJECT_SOURCE_DIR}/src/core/include/*
+  ${PROJECT_SOURCE_DIR}/src/opr/include/*
+  ${PROJECT_SOURCE_DIR}/src/serialization/include/*
+  ${PROJECT_SOURCE_DIR}/src/plugin/include/*
+  ${PROJECT_SOURCE_DIR}/dnn/include/*)
 
 set(MEGENGINE_DIR ${CMAKE_CURRENT_BINARY_DIR}/python/)
 
@@ -23,74 +30,106 @@ add_subdirectory(tablegen)
 
 add_custom_target(_version_ld SOURCES ${MGE_VERSION_SCRIPT})
 
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/pybind11 ${PROJECT_BINARY_DIR}/third_party/pybind11)
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/pybind11
+                 ${PROJECT_BINARY_DIR}/third_party/pybind11)
 pybind11_add_module(${MODULE_NAME} NO_EXTRAS ${SRCS})
-if (APPLE)
-    target_link_libraries(${MODULE_NAME} PRIVATE megengine_shared)
-elseif (MSVC OR WIN32)
-    target_link_libraries(${MODULE_NAME} PRIVATE megengine_shared)
-    message(STATUS "CMAKE_MSVC_RUNTIME_LIBRARY: ${CMAKE_MSVC_RUNTIME_LIBRARY}")
-    set_target_properties(${MODULE_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY "${CMAKE_MSVC_RUNTIME_LIBRARY}")
+if(APPLE)
+  target_link_libraries(${MODULE_NAME} PRIVATE megengine_shared)
+elseif(MSVC OR WIN32)
+  target_link_libraries(${MODULE_NAME} PRIVATE megengine_shared)
+  message(STATUS "CMAKE_MSVC_RUNTIME_LIBRARY: ${CMAKE_MSVC_RUNTIME_LIBRARY}")
+  set_target_properties(${MODULE_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY
+                                                  "${CMAKE_MSVC_RUNTIME_LIBRARY}")
 else()
-    # use to fix runtime crash when build both mgb(MGE_WITH_PYTHON_MODULE) and imperative(MGE_BUILD_IMPERATIVE_RT)
-    target_link_libraries(${MODULE_NAME} PRIVATE megengine_shared -Wl,--version-script=${MGE_VERSION_SCRIPT})
+  # use to fix runtime crash when build both mgb(MGE_WITH_PYTHON_MODULE) and
+  # imperative(MGE_BUILD_IMPERATIVE_RT)
+  target_link_libraries(
+    ${MODULE_NAME} PRIVATE megengine_shared -Wl,--version-script=${MGE_VERSION_SCRIPT})
 endif()
 
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/range-v3 ${PROJECT_BINARY_DIR}/third_party/range-v3)
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/range-v3
+                 ${PROJECT_BINARY_DIR}/third_party/range-v3)
 target_link_libraries(${MODULE_NAME} PRIVATE range-v3)
 
-add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/Json ${PROJECT_BINARY_DIR}/third_party/Json)
+add_subdirectory(${PROJECT_SOURCE_DIR}/third_party/Json
+                 ${PROJECT_BINARY_DIR}/third_party/Json)
 target_link_libraries(${MODULE_NAME} PRIVATE nlohmann_json::nlohmann_json)
 
-target_include_directories(${MODULE_NAME} PUBLIC src/include PRIVATE ${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIR} ${MGB_OPDEF_OUT_DIR} ${CPP_REDIS_INCLUDES})
+target_include_directories(
+  ${MODULE_NAME}
+  PUBLIC src/include
+  PRIVATE ${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIR} ${MGB_OPDEF_OUT_DIR}
+          ${CPP_REDIS_INCLUDES})
 target_compile_definitions(${MODULE_NAME} PRIVATE MODULE_NAME=${MODULE_NAME})
 target_compile_options(${MODULE_NAME} PRIVATE -Wno-unused-parameter)
 if(CXX_SUPPORT_WCLASS_MEMACCESS)
-    target_compile_options(${MODULE_NAME} PRIVATE "-Wno-class-memaccess")
+  target_compile_options(${MODULE_NAME} PRIVATE "-Wno-class-memaccess")
 endif()
-set_target_properties(${MODULE_NAME} PROPERTIES
-    SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}
-    LIBRARY_OUTPUT_DIRECTORY ${MEGENGINE_DIR}/${PACKAGE_NAME}/core
-)
-if (APPLE OR MSVC OR WIN32)
-    message(VERBOSE "overwriting SUFFIX at macos and windows before config by set_target_properties")
-    pybind11_extension(${MODULE_NAME})
+set_target_properties(
+  ${MODULE_NAME}
+  PROPERTIES SUFFIX ${CMAKE_SHARED_LIBRARY_SUFFIX}
+             LIBRARY_OUTPUT_DIRECTORY ${MEGENGINE_DIR}/${PACKAGE_NAME}/core)
+if(APPLE
+   OR MSVC
+   OR WIN32)
+  message(
+    VERBOSE
+    "overwriting SUFFIX at macos and windows before config by set_target_properties")
+  pybind11_extension(${MODULE_NAME})
 endif()
 add_dependencies(${MODULE_NAME} mgb_opdef _version_ld)
 
 if(MGE_WITH_TEST AND MGE_ENABLE_RTTI)
-    add_subdirectory(test)
+  add_subdirectory(test)
 endif()
 
 add_custom_command(
-    TARGET ${MODULE_NAME} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/LICENSE ${PROJECT_SOURCE_DIR}/ACKNOWLEDGMENTS ${PROJECT_BINARY_DIR}
-    COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/$<TARGET_FILE_NAME:${MODULE_NAME}> # clean develop
-    COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/version.py # clean develop
-    COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/include # clean develop
-    COMMAND ${CMAKE_COMMAND} -E remove -f ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/lib # clean develop
-    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine ${CMAKE_CURRENT_BINARY_DIR}/python/megengine
-    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/python/test ${CMAKE_CURRENT_BINARY_DIR}/python/test
-    COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/src/custom/include ${CMAKE_CURRENT_BINARY_DIR}/python/megengine/core/include
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py ${CMAKE_CURRENT_BINARY_DIR}/python/setup.py
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires.txt ${CMAKE_CURRENT_BINARY_DIR}/python/requires.txt
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-style.txt ${CMAKE_CURRENT_BINARY_DIR}/python/requires-style.txt
-    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-test.txt ${CMAKE_CURRENT_BINARY_DIR}/python/requires-test.txt
-)
+  TARGET ${MODULE_NAME}
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/LICENSE
+          ${PROJECT_SOURCE_DIR}/ACKNOWLEDGMENTS ${PROJECT_BINARY_DIR}
+  COMMAND
+    ${CMAKE_COMMAND} -E remove -f
+    ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/$<TARGET_FILE_NAME:${MODULE_NAME}> # clean
+                                                                                         # develop
+  COMMAND ${CMAKE_COMMAND} -E remove -f
+          ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/version.py # clean develop
+  COMMAND ${CMAKE_COMMAND} -E remove -f
+          ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/include # clean develop
+  COMMAND ${CMAKE_COMMAND} -E remove -f
+          ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine/core/lib # clean develop
+  COMMAND
+    ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/python/megengine
+    ${CMAKE_CURRENT_BINARY_DIR}/python/megengine
+  COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/python/test
+          ${CMAKE_CURRENT_BINARY_DIR}/python/test
+  COMMAND ${CMAKE_COMMAND} -E copy_directory ${PROJECT_SOURCE_DIR}/src/custom/include
+          ${CMAKE_CURRENT_BINARY_DIR}/python/megengine/core/include
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/setup.py
+          ${CMAKE_CURRENT_BINARY_DIR}/python/setup.py
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires.txt
+          ${CMAKE_CURRENT_BINARY_DIR}/python/requires.txt
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-style.txt
+          ${CMAKE_CURRENT_BINARY_DIR}/python/requires-style.txt
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/python/requires-test.txt
+          ${CMAKE_CURRENT_BINARY_DIR}/python/requires-test.txt)
 
 if(DEFINED MGB_VER_MAJOR)
-    set(IS_INTERNAL "--internal")
+  set(IS_INTERNAL "--internal")
 else()
-    set(IS_INTERNAL "")
+  set(IS_INTERNAL "")
 endif(DEFINED MGB_VER_MAJOR)
 
 if(DEFINED MGE_EXTRA_NAME)
-    set(RC_NAME "--rc=${MGE_EXTRA_NAME}")
+  set(RC_NAME "--rc=${MGE_EXTRA_NAME}")
 else()
-    set(RC_NAME "")
+  set(RC_NAME "")
 endif(DEFINED MGE_EXTRA_NAME)
 
 add_custom_command(
-    TARGET ${MODULE_NAME} POST_BUILD
-    COMMAND "${PYTHON_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/python/gen_version.py --output ${CMAKE_CURRENT_BINARY_DIR}/python/megengine/version.py --major ${MGE_VER_MAJOR} --minor ${MGE_VER_MINOR} --patch ${MGE_VER_PATCH} ${RC_NAME} ${IS_INTERNAL}
-)
+  TARGET ${MODULE_NAME}
+  POST_BUILD
+  COMMAND
+    "${PYTHON_EXECUTABLE}" ${CMAKE_CURRENT_SOURCE_DIR}/python/gen_version.py --output
+    ${CMAKE_CURRENT_BINARY_DIR}/python/megengine/version.py --major ${MGE_VER_MAJOR}
+    --minor ${MGE_VER_MINOR} --patch ${MGE_VER_PATCH} ${RC_NAME} ${IS_INTERNAL})

imperative/tablegen/CMakeLists.txt

@@ -1,6 +1,7 @@
 # mgb tablegen executable
 set(TABLE_TARGET mgb-mlir-autogen)
-file(GLOB_RECURSE SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB_RECURSE SRCS ${CMAKE_CURRENT_SOURCE_DIR}/*.h
+     ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
 add_executable(${TABLE_TARGET} ${SRCS})
 target_include_directories(${TABLE_TARGET} PRIVATE ${MLIR_LLVM_INCLUDE_DIR})
 target_link_libraries(${TABLE_TARGET} PRIVATE LLVMTableGen MLIRTableGen LLVMSupport)
@@ -13,5 +14,8 @@ tablegen(MGB opdef.cpp.inl ${MGE_IR_INCLUDE_DIRS} "--gen-cpp-body")
 tablegen(MGB opdef.py.inl ${MGE_IR_INCLUDE_DIRS} "--gen-python-binding")
 tablegen(MGB opdef.cpy.inl ${MGE_IR_INCLUDE_DIRS} "--gen-python-c-extension")
 tablegen(MGB enum_macro.h ${MGE_IR_INCLUDE_DIRS} "--gen-enum-list-macro")
-add_custom_target(mgb_opdef ALL DEPENDS opdef.h.inl opdef.cpp.inl opdef.py.inl opdef.cpy.inl enum_macro.h param_defs_tblgen)
-set(MGB_OPDEF_OUT_DIR ${CMAKE_CURRENT_BINARY_DIR} PARENT_SCOPE)
+add_custom_target(mgb_opdef ALL DEPENDS opdef.h.inl opdef.cpp.inl opdef.py.inl
+                                        opdef.cpy.inl enum_macro.h param_defs_tblgen)
+set(MGB_OPDEF_OUT_DIR
+    ${CMAKE_CURRENT_BINARY_DIR}
+    PARENT_SCOPE)

imperative/test/CMakeLists.txt

@@ -5,46 +5,60 @@ file(GLOB_RECURSE SOURCES ../src/test/*.cpp ../src/impl/*.cpp ${MGB_TEST_DIR}/*.
 
 # disable distributed tests
 if(NOT MGE_WITH_DISTRIBUTED)
-    list(FILTER SOURCES EXCLUDE REGEX ".*test/collective_comm.cpp")
-    list(FILTER SOURCES EXCLUDE REGEX ".*test/io_remote.cpp")
+  list(FILTER SOURCES EXCLUDE REGEX ".*test/collective_comm.cpp")
+  list(FILTER SOURCES EXCLUDE REGEX ".*test/io_remote.cpp")
 endif()
 
 # TODO: turn python binding into a static/object library
 add_executable(imperative_test ${SOURCES} ${SRCS})
 add_dependencies(imperative_test mgb_opdef)
-target_include_directories(imperative_test PRIVATE ${MGB_TEST_DIR}/include ../src/include ${MGB_OPDEF_OUT_DIR} ${CPP_REDIS_INCLUDES})
+target_include_directories(
+  imperative_test PRIVATE ${MGB_TEST_DIR}/include ../src/include ${MGB_OPDEF_OUT_DIR}
+                          ${CPP_REDIS_INCLUDES})
 
 # Python binding
-target_include_directories(imperative_test PRIVATE ${MODULE_SRC_INCLUDE} ${PYTHON_INCLUDE_DIRS} ${NUMPY_INCLUDE_DIR})
+target_include_directories(
+  imperative_test PRIVATE ${MODULE_SRC_INCLUDE} ${PYTHON_INCLUDE_DIRS}
+                          ${NUMPY_INCLUDE_DIR})
 target_compile_definitions(imperative_test PRIVATE MODULE_NAME=C)
 target_compile_options(imperative_test PRIVATE -Wno-unused-parameter)
 
-set(LINK_LIBS megbrain megdnn ${MGE_CUDA_LIBS} gtest gmock pybind11::embed range-v3 nlohmann_json::nlohmann_json)
+set(LINK_LIBS
+    megbrain
+    megdnn
+    ${MGE_CUDA_LIBS}
+    gtest
+    gmock
+    pybind11::embed
+    range-v3
+    nlohmann_json::nlohmann_json)
 
 if(MGE_WITH_CUDA)
-    list(APPEND LINK_LIBS cudart)
+  list(APPEND LINK_LIBS cudart)
 endif()
 
 if(MGE_WITH_DISTRIBUTED)
-    list(APPEND LINK_LIBS megray)
+  list(APPEND LINK_LIBS megray)
 endif()
 
 target_link_libraries(imperative_test ${LINK_LIBS})
 if(CXX_SUPPORT_WCLASS_MEMACCESS)
-    if(MGE_WITH_CUDA)
-        target_compile_options(imperative_test PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
-            "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
-    else()
-        target_compile_options(imperative_test PRIVATE "-Wno-class-memaccess")
-    endif()
+  if(MGE_WITH_CUDA)
+    target_compile_options(
+      imperative_test
+      PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
+              "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
+  else()
+    target_compile_options(imperative_test PRIVATE "-Wno-class-memaccess")
+  endif()
 endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(imperative_test dl)
-    else()
-        target_link_libraries(imperative_test dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(imperative_test dl)
+  else()
+    target_link_libraries(imperative_test dl rt)
+  endif()
 endif()
 
 install(TARGETS imperative_test RUNTIME DESTINATION test)

lite/CMakeLists.txt

@@ -8,155 +8,185 @@ set(LITE_ENABLE_EXCEPTION ${MGE_ENABLE_EXCEPTIONS})
 set(LITE_ASSERT_LOC ${MGB_ASSERT_LOC})
 
 if(NOT MGB_WITH_FLATBUFFERS)
-    include(../cmake/flatbuffers.cmake)
+  include(../cmake/flatbuffers.cmake)
 endif()
 
 file(GLOB_RECURSE SRC_FBS src/**/*.fbs)
 build_flatbuffers(
-    "${SRC_FBS}"
-    ""
-    lite_fbs_generate
-    ""
-    "${CMAKE_CURRENT_BINARY_DIR}"
-    ""
-    ""
-    )
+  "${SRC_FBS}"
+  ""
+  lite_fbs_generate
+  ""
+  "${CMAKE_CURRENT_BINARY_DIR}"
+  ""
+  "")
 
 file(GLOB_RECURSE SOURCES_LITE src/*.cpp src/*.cc lite-c/*.cpp)
 
 if(MGE_WITH_MINIMUM_SIZE)
-    set(LITE_ENABLE_LOGGING OFF)
-    set(LITE_ENABLE_EXCEPTION OFF)
+  set(LITE_ENABLE_LOGGING OFF)
+  set(LITE_ENABLE_EXCEPTION OFF)
 endif()
 
-# Write out lite_build_config.h
-# It defines macros needed by lite
-configure_file(src/lite_build_config.h.in ${CMAKE_CURRENT_BINARY_DIR}/genfiles/lite_build_config.h)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/genfiles/lite_build_config.h DESTINATION ${CMAKE_INSTALL_PREFIX}/lite/include)
+# Write out lite_build_config.h It defines macros needed by lite
+configure_file(src/lite_build_config.h.in
+               ${CMAKE_CURRENT_BINARY_DIR}/genfiles/lite_build_config.h)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/genfiles/lite_build_config.h
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/lite/include)
 
 # begin config lite
-if(LITE_BUILD_WITH_MGE AND LITE_WITH_CUDA AND NOT WIN32)
-    # FXIME third_party cpp redis do not support build with clang-cl
-    list(APPEND SOURCES_LITE ${CPP_REDIS_SRCS})
+if(LITE_BUILD_WITH_MGE
+   AND LITE_WITH_CUDA
+   AND NOT WIN32)
+  # FXIME third_party cpp redis do not support build with clang-cl
+  list(APPEND SOURCES_LITE ${CPP_REDIS_SRCS})
 endif()
 add_library(lite_static STATIC ${SOURCES_LITE})
 add_dependencies(lite_static lite_fbs_generate)
 include_directories($<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/genfiles>)
 
 if(LITE_BUILD_WITH_MGE)
-    target_link_libraries(lite_static PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
-    add_compile_definitions(LITE_BUILD_WITH_MGE=1)
-    message(STATUS "build lite with MegEngine.")
+  target_link_libraries(lite_static PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
+  add_compile_definitions(LITE_BUILD_WITH_MGE=1)
+  message(STATUS "build lite with MegEngine.")
 else()
-    target_link_libraries(lite_static PUBLIC flatbuffers)
+  target_link_libraries(lite_static PUBLIC flatbuffers)
 endif()
 
 include_directories(
-    PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/lite/include>
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/include>
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/include/lite>
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/lite-c/include>
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/src>
-    PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/Json/include>
-    )
+  PUBLIC
+  $<INSTALL_INTERFACE:${CMAKE_INSTALL_PREFIX}/lite/include>
+  PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/include>
+  PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/include/lite>
+  PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/lite-c/include>
+  PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/src>
+  PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/Json/include>)
 # end config lite
 
 # define a shared lib
 add_library(lite_shared SHARED $<TARGET_OBJECTS:lite_static>)
 if(LITE_BUILD_WITH_MGE)
-    target_link_libraries(lite_shared PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
+  target_link_libraries(lite_shared PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
 endif()
 if(ANDROID)
-    link_libraries(log)
-    target_link_libraries(lite_static PRIVATE log)
-    target_link_libraries(lite_shared PRIVATE log)
+  link_libraries(log)
+  target_link_libraries(lite_static PRIVATE log)
+  target_link_libraries(lite_shared PRIVATE log)
 endif()
 
 # define a shared lib for whl
 add_library(lite_shared_whl SHARED $<TARGET_OBJECTS:lite_static>)
 if(LITE_BUILD_WITH_MGE)
-    if (IOS)
-        target_link_libraries(lite_shared_whl PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
-    else()
-        target_link_libraries(lite_shared_whl PRIVATE megengine_shared)
-    endif()
+  if(IOS)
+    target_link_libraries(lite_shared_whl PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
+  else()
+    target_link_libraries(lite_shared_whl PRIVATE megengine_shared)
+  endif()
 endif()
 if(ANDROID)
-    target_link_libraries(lite_shared_whl PRIVATE log)
+  target_link_libraries(lite_shared_whl PRIVATE log)
 endif()
 
-# add lite_static_all_in_one same name build by BUILD
-# please do not change flatbuffers/cpuinfo/clog/lite_static order, if change!, cmake
-# can not gen flatbuffers/cpuinfo/clog OBJs to lite_static_all_in_one, this may cmake issue
-# NOTICE: this target always use to separate build with lite, if build lite via include
+# add lite_static_all_in_one same name build by BUILD please do not change
+# flatbuffers/cpuinfo/clog/lite_static order, if change!, cmake can not gen
+# flatbuffers/cpuinfo/clog OBJs to lite_static_all_in_one, this may cmake issue NOTICE:
+# this target always use to separate build with lite, if build lite via include
 # MegEngine/megbrain ROOT_DIR/CMakeLists.txt, just depends lite_static or lite_shared
-#TODO: need refine lite_static_all_in_one depend objects, but now cmake do not support
+# TODO: need refine lite_static_all_in_one depend objects, but now cmake do not support
 # define a add_library which OBJECTS args is a set or list or string
-if (MGE_ENABLE_CPUINFO AND MGE_WITH_OPENCL)
-    add_library(lite_static_all_in_one STATIC $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:cpuinfo> $<TARGET_OBJECTS:clog> $<TARGET_OBJECTS:OpenCL> $<TARGET_OBJECTS:lite_static>)
-elseif (MGE_ENABLE_CPUINFO AND NOT MGE_WITH_OPENCL)
-    add_library(lite_static_all_in_one STATIC $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:cpuinfo> $<TARGET_OBJECTS:clog> $<TARGET_OBJECTS:lite_static>)
-elseif (NOT MGE_ENABLE_CPUINFO AND MGE_WITH_OPENCL)
-    add_library(lite_static_all_in_one STATIC $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:OpenCL> $<TARGET_OBJECTS:lite_static>)
+if(MGE_ENABLE_CPUINFO AND MGE_WITH_OPENCL)
+  add_library(
+    lite_static_all_in_one STATIC
+    $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:cpuinfo> $<TARGET_OBJECTS:clog>
+    $<TARGET_OBJECTS:OpenCL> $<TARGET_OBJECTS:lite_static>)
+elseif(MGE_ENABLE_CPUINFO AND NOT MGE_WITH_OPENCL)
+  add_library(
+    lite_static_all_in_one STATIC
+    $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:cpuinfo> $<TARGET_OBJECTS:clog>
+    $<TARGET_OBJECTS:lite_static>)
+elseif(NOT MGE_ENABLE_CPUINFO AND MGE_WITH_OPENCL)
+  add_library(
+    lite_static_all_in_one STATIC
+    $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:OpenCL>
+    $<TARGET_OBJECTS:lite_static>)
 else()
-    add_library(lite_static_all_in_one STATIC $<TARGET_OBJECTS:flatbuffers> $<TARGET_OBJECTS:lite_static>)
+  add_library(lite_static_all_in_one STATIC $<TARGET_OBJECTS:flatbuffers>
+                                            $<TARGET_OBJECTS:lite_static>)
 endif()
 if(LITE_BUILD_WITH_MGE)
-    target_link_libraries(lite_static_all_in_one PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
+  target_link_libraries(lite_static_all_in_one PRIVATE megbrain megdnn ${MGE_CUDA_LIBS})
 endif()
 
-if(LITE_BUILD_WITH_MGE AND LITE_WITH_CUDA AND NOT WIN32)
-    # FXIME third_party cpp redis do not support build with clang-cl
-    target_include_directories(lite_static PRIVATE ${CPP_REDIS_INCLUDES})
-    target_include_directories(lite_shared PRIVATE ${CPP_REDIS_INCLUDES})
-    target_include_directories(lite_shared_whl PRIVATE ${CPP_REDIS_INCLUDES})
-    target_include_directories(lite_static_all_in_one PRIVATE ${CPP_REDIS_INCLUDES})
+if(LITE_BUILD_WITH_MGE
+   AND LITE_WITH_CUDA
+   AND NOT WIN32)
+  # FXIME third_party cpp redis do not support build with clang-cl
+  target_include_directories(lite_static PRIVATE ${CPP_REDIS_INCLUDES})
+  target_include_directories(lite_shared PRIVATE ${CPP_REDIS_INCLUDES})
+  target_include_directories(lite_shared_whl PRIVATE ${CPP_REDIS_INCLUDES})
+  target_include_directories(lite_static_all_in_one PRIVATE ${CPP_REDIS_INCLUDES})
 endif()
-set(LITE_VERSION_SCRIPT ${PROJECT_SOURCE_DIR}/lite/src/version_lite.ld CACHE INTERNAL "Path to linker version script")
+set(LITE_VERSION_SCRIPT
+    ${PROJECT_SOURCE_DIR}/lite/src/version_lite.ld
+    CACHE INTERNAL "Path to linker version script")
 add_custom_target(_lite_version_ld SOURCES ${LITE_VERSION_SCRIPT})
 if(NOT MSVC AND NOT WIN32)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
 endif()
-#TODO: implemente version script for other OS
-if (UNIX AND NOT APPLE)
-    target_link_options(lite_shared PRIVATE -Wl,--version-script=${LITE_VERSION_SCRIPT})
-    set_target_properties(lite_shared PROPERTIES LINK_DEPENDS ${LITE_VERSION_SCRIPT})
-    target_link_options(lite_shared_whl PRIVATE -Wl,--version-script=${LITE_VERSION_SCRIPT})
-    set_target_properties(lite_shared_whl PROPERTIES LINK_DEPENDS ${LITE_VERSION_SCRIPT})
+# TODO: implemente version script for other OS
+if(UNIX AND NOT APPLE)
+  target_link_options(lite_shared PRIVATE -Wl,--version-script=${LITE_VERSION_SCRIPT})
+  set_target_properties(lite_shared PROPERTIES LINK_DEPENDS ${LITE_VERSION_SCRIPT})
+  target_link_options(lite_shared_whl PRIVATE
+                      -Wl,--version-script=${LITE_VERSION_SCRIPT})
+  set_target_properties(lite_shared_whl PROPERTIES LINK_DEPENDS ${LITE_VERSION_SCRIPT})
 endif()
 
 # config install
-install(TARGETS lite_static
-    LIBRARY DESTINATION lite/lib/${MGE_ARCH}
-    FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
-    ARCHIVE DESTINATION lite/lib/${MGE_ARCH})
-
-install(TARGETS lite_shared
-    LIBRARY DESTINATION lite/lib/${MGE_ARCH}
-    FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
-    ARCHIVE DESTINATION lite/lib/${MGE_ARCH}
-    )
-
-install(TARGETS lite_static_all_in_one
-    LIBRARY DESTINATION lite/lib/${MGE_ARCH}
-    FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
-    ARCHIVE DESTINATION lite/lib/${MGE_ARCH})
+install(
+  TARGETS lite_static
+  LIBRARY DESTINATION lite/lib/${MGE_ARCH}
+  FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
+  ARCHIVE DESTINATION lite/lib/${MGE_ARCH})
+
+install(
+  TARGETS lite_shared
+  LIBRARY DESTINATION lite/lib/${MGE_ARCH}
+  FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
+  ARCHIVE DESTINATION lite/lib/${MGE_ARCH})
+
+install(
+  TARGETS lite_static_all_in_one
+  LIBRARY DESTINATION lite/lib/${MGE_ARCH}
+  FRAMEWORK DESTINATION lite/lib/${MGE_ARCH}
+  ARCHIVE DESTINATION lite/lib/${MGE_ARCH})
 install(FILES ${PROJECT_SOURCE_DIR}/lite/include/lite/common_enum_c.h
-    DESTINATION ${CMAKE_INSTALL_PREFIX}/lite/include/lite-c)
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/lite/include/lite-c)
 
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/lite/include
-    DESTINATION ${CMAKE_INSTALL_PREFIX}/lite FILES_MATCHING PATTERN "*.h")
+install(
+  DIRECTORY ${PROJECT_SOURCE_DIR}/lite/include
+  DESTINATION ${CMAKE_INSTALL_PREFIX}/lite
+  FILES_MATCHING
+  PATTERN "*.h")
 
-install(DIRECTORY ${PROJECT_SOURCE_DIR}/lite/lite-c/include
-    DESTINATION ${CMAKE_INSTALL_PREFIX}/lite FILES_MATCHING PATTERN "*.h")
+install(
+  DIRECTORY ${PROJECT_SOURCE_DIR}/lite/lite-c/include
+  DESTINATION ${CMAKE_INSTALL_PREFIX}/lite
+  FILES_MATCHING
+  PATTERN "*.h")
 
 add_subdirectory(example)
 if(MGE_WITH_TEST)
-    add_subdirectory(test)
+  add_subdirectory(test)
 endif()
 
-#load_and_run
+# load_and_run
 add_subdirectory(load_and_run)
 
 # tools and example
@@ -164,11 +194,12 @@ add_executable(rc4_encryptor tools/rc4_encrypt.cpp)
 
 target_link_libraries(rc4_encryptor lite_static)
 if(LITE_BUILD_WITH_MGE AND MGE_WITH_ROCM)
-    # FIXME: hip obj can not find cpp obj only through lite_static
-    target_link_libraries(rc4_encryptor megdnn)
+  # FIXME: hip obj can not find cpp obj only through lite_static
+  target_link_libraries(rc4_encryptor megdnn)
 endif()
-target_include_directories(rc4_encryptor PRIVATE
-    {PROJECT_SOURCE_DIR}/lite/src/decryption)
-install (TARGETS rc4_encryptor
-    EXPORT ${LITE_EXPORT_TARGETS}
-    RUNTIME DESTINATION lite/tools)
+target_include_directories(rc4_encryptor
+                           PRIVATE {PROJECT_SOURCE_DIR}/lite/src/decryption)
+install(
+  TARGETS rc4_encryptor
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION lite/tools)

lite/example/c_example/CMakeLists.txt

@@ -1,44 +1,46 @@
 add_executable(lite_c_examples ./main.c)
 if(LITE_BUILD_WITH_RKNPU)
-    #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-    target_link_options(lite_c_examples  PRIVATE "-fuse-ld=gold")
+  # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+  target_link_options(lite_c_examples PRIVATE "-fuse-ld=gold")
 endif()
 target_link_libraries(lite_c_examples lite_static)
 if(LITE_BUILD_WITH_MGE AND MGE_WITH_ROCM)
-    # FIXME: hip obj can not find cpp obj only through lite_static
-    target_link_libraries(lite_c_examples megdnn)
+  # FIXME: hip obj can not find cpp obj only through lite_static
+  target_link_libraries(lite_c_examples megdnn)
 endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(lite_c_examples dl)
-    else()
-        target_link_libraries(lite_c_examples dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(lite_c_examples dl)
+  else()
+    target_link_libraries(lite_c_examples dl rt)
+  endif()
 endif()
 
-install (TARGETS lite_c_examples
-    EXPORT ${LITE_EXPORT_TARGETS}
-    RUNTIME DESTINATION lite/bin)
+install(
+  TARGETS lite_c_examples
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION lite/bin)
 
 # add lite_examples_depends_shared for CI check symbol export valid
-add_executable(lite_c_examples_depends_shared  ./main.c)
+add_executable(lite_c_examples_depends_shared ./main.c)
 
 if(LITE_BUILD_WITH_RKNPU)
-    #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-    target_link_options(lite_c_examples_depends_shared  PRIVATE "-fuse-ld=gold")
+  # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+  target_link_options(lite_c_examples_depends_shared PRIVATE "-fuse-ld=gold")
 endif()
 
 target_link_libraries(lite_c_examples_depends_shared lite_shared)
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(lite_c_examples_depends_shared dl)
-    else()
-        target_link_libraries(lite_c_examples_depends_shared dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(lite_c_examples_depends_shared dl)
+  else()
+    target_link_libraries(lite_c_examples_depends_shared dl rt)
+  endif()
 endif()
 
-install (TARGETS lite_c_examples_depends_shared
-    EXPORT ${LITE_EXPORT_TARGETS}
-    RUNTIME DESTINATION lite/bin)
+install(
+  TARGETS lite_c_examples_depends_shared
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION lite/bin)

lite/example/cpp_example/CMakeLists.txt

@@ -1,49 +1,51 @@
-file (GLOB_RECURSE SOURCES ./*.cpp)
-add_executable(lite_examples  ${SOURCES})
+file(GLOB_RECURSE SOURCES ./*.cpp)
+add_executable(lite_examples ${SOURCES})
 target_include_directories(lite_examples PUBLIC ./)
 
 if(LITE_BUILD_WITH_RKNPU)
-    #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-    target_link_options(lite_examples  PRIVATE "-fuse-ld=gold")
+  # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+  target_link_options(lite_examples PRIVATE "-fuse-ld=gold")
 endif()
 
 target_link_libraries(lite_examples lite_static)
 if(LITE_BUILD_WITH_MGE AND MGE_WITH_ROCM)
-    # FIXME: hip obj can not find cpp obj only through lite_static
-    target_link_libraries(lite_examples megdnn)
+  # FIXME: hip obj can not find cpp obj only through lite_static
+  target_link_libraries(lite_examples megdnn)
 endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(lite_examples dl)
-    else()
-        target_link_libraries(lite_examples dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(lite_examples dl)
+  else()
+    target_link_libraries(lite_examples dl rt)
+  endif()
 endif()
 
-install (TARGETS lite_examples
-    EXPORT ${LITE_EXPORT_TARGETS}
-    RUNTIME DESTINATION lite/bin)
+install(
+  TARGETS lite_examples
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION lite/bin)
 
 # add lite_examples_depends_shared for CI check symbol export valid
-add_executable(lite_examples_depends_shared  ${SOURCES})
+add_executable(lite_examples_depends_shared ${SOURCES})
 
 if(LITE_BUILD_WITH_RKNPU)
-    #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-    target_link_options(lite_examples_depends_shared  PRIVATE "-fuse-ld=gold")
+  # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+  target_link_options(lite_examples_depends_shared PRIVATE "-fuse-ld=gold")
 endif()
 
 target_link_libraries(lite_examples_depends_shared lite_shared)
 target_include_directories(lite_examples_depends_shared PUBLIC ./)
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(lite_examples_depends_shared dl)
-    else()
-        target_link_libraries(lite_examples_depends_shared dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(lite_examples_depends_shared dl)
+  else()
+    target_link_libraries(lite_examples_depends_shared dl rt)
+  endif()
 endif()
 
-install (TARGETS lite_examples_depends_shared
-    EXPORT ${LITE_EXPORT_TARGETS}
-    RUNTIME DESTINATION lite/bin)
+install(
+  TARGETS lite_examples_depends_shared
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION lite/bin)

lite/load_and_run/CMakeLists.txt

@@ -1,55 +1,62 @@
 # BUILD the load and run for lite
-include_directories(PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/load_and_run/src>)
-file (GLOB_RECURSE SOURCES ./*.cpp)
+include_directories(PUBLIC
+                    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/lite/load_and_run/src>)
+file(GLOB_RECURSE SOURCES ./*.cpp)
 
-add_executable (load_and_run  ${SOURCES})
+add_executable(load_and_run ${SOURCES})
 
 target_link_libraries(load_and_run lite_static)
 target_link_libraries(load_and_run megbrain)
 target_link_libraries(load_and_run gflags)
 
 if(LITE_BUILD_WITH_RKNPU)
-    #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-    target_link_options(load_and_run  PRIVATE "-fuse-ld=gold")
+  # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+  target_link_options(load_and_run PRIVATE "-fuse-ld=gold")
 endif()
 
 if(MGE_WITH_ROCM)
-    # FIXME: hip obj can not find cpp obj only through lite_static
-    target_link_libraries(load_and_run megdnn)
+  # FIXME: hip obj can not find cpp obj only through lite_static
+  target_link_libraries(load_and_run megdnn)
 endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(load_and_run dl)
-    else()
-        target_link_libraries(load_and_run dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(load_and_run dl)
+  else()
+    target_link_libraries(load_and_run dl rt)
+  endif()
 endif()
 
-install (TARGETS load_and_run EXPORT ${LITE_EXPORT_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(
+  TARGETS load_and_run
+  EXPORT ${LITE_EXPORT_TARGETS}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 if(BUILD_SHARED_LIBS)
-    add_executable(load_and_run_depends_shared ${SOURCES})
-    target_link_libraries(load_and_run_depends_shared lite_shared)
-    target_link_libraries(load_and_run_depends_shared gflags)
-    target_link_libraries(load_and_run_depends_shared megengine)
-
-    if(LITE_BUILD_WITH_RKNPU)
-        #rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
-        target_link_options(load_and_run_depends_shared  PRIVATE "-fuse-ld=gold")
-    endif()
+  add_executable(load_and_run_depends_shared ${SOURCES})
+  target_link_libraries(load_and_run_depends_shared lite_shared)
+  target_link_libraries(load_and_run_depends_shared gflags)
+  target_link_libraries(load_and_run_depends_shared megengine)
 
-    if(MGE_WITH_ROCM)
-        # FIXME: hip obj can not find cpp obj only through lite_static
-        target_link_libraries(load_and_run_depends_shared megdnn)
-    endif()
+  if(LITE_BUILD_WITH_RKNPU)
+    # rknn sdk1.0.0 depend on libc++_shared, use gold to remove NEEDED so symbol check
+    target_link_options(load_and_run_depends_shared PRIVATE "-fuse-ld=gold")
+  endif()
+
+  if(MGE_WITH_ROCM)
+    # FIXME: hip obj can not find cpp obj only through lite_static
+    target_link_libraries(load_and_run_depends_shared megdnn)
+  endif()
 
-    if(UNIX)
-        if(APPLE OR ANDROID)
-            target_link_libraries(load_and_run_depends_shared dl)
-        else()
-            target_link_libraries(load_and_run_depends_shared dl rt)
-        endif()
+  if(UNIX)
+    if(APPLE OR ANDROID)
+      target_link_libraries(load_and_run_depends_shared dl)
+    else()
+      target_link_libraries(load_and_run_depends_shared dl rt)
     endif()
+  endif()
 
-    install(TARGETS load_and_run_depends_shared EXPORT ${MGE_EXPORT_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+  install(
+    TARGETS load_and_run_depends_shared
+    EXPORT ${MGE_EXPORT_TARGETS}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()

lite/test/CMakeLists.txt

@@ -1,27 +1,28 @@
-if (MGE_WITH_TEST)
-    file (GLOB_RECURSE SOURCES ./*.cpp main.cpp)
-    add_executable (lite_test  ${SOURCES})
+if(MGE_WITH_TEST)
+  file(GLOB_RECURSE SOURCES ./*.cpp main.cpp)
+  add_executable(lite_test ${SOURCES})
 
-    target_link_libraries(lite_test gtest)
-    target_link_libraries(lite_test lite_static)
-    if(LITE_BUILD_WITH_MGE)
-        # lite_test will depends megbrain interface
-        target_link_libraries(lite_test megbrain)
-        if (MGE_WITH_ROCM)
-            # FIXME: hip obj can not find cpp obj only through lite_static
-            target_link_libraries(lite_test megdnn)
-        endif ()
+  target_link_libraries(lite_test gtest)
+  target_link_libraries(lite_test lite_static)
+  if(LITE_BUILD_WITH_MGE)
+    # lite_test will depends megbrain interface
+    target_link_libraries(lite_test megbrain)
+    if(MGE_WITH_ROCM)
+      # FIXME: hip obj can not find cpp obj only through lite_static
+      target_link_libraries(lite_test megdnn)
     endif()
+  endif()
 
-    if(UNIX)
-        if(APPLE OR ANDROID)
-            target_link_libraries(lite_test dl)
-        else()
-            target_link_libraries(lite_test dl rt)
-        endif()
+  if(UNIX)
+    if(APPLE OR ANDROID)
+      target_link_libraries(lite_test dl)
+    else()
+      target_link_libraries(lite_test dl rt)
     endif()
+  endif()
 
-    install (TARGETS lite_test
-        EXPORT ${LITE_EXPORT_TARGETS}
-        RUNTIME DESTINATION lite/bin)
+  install(
+    TARGETS lite_test
+    EXPORT ${LITE_EXPORT_TARGETS}
+    RUNTIME DESTINATION lite/bin)
 endif()

src/CMakeLists.txt

@@ -1,213 +1,242 @@
-# force define a SHARED target for whl, caused by when build for APPLE
-# we will force set BUILD_SHARED_LIBS=OFF for xcode needed
+# force define a SHARED target for whl, caused by when build for APPLE we will force set
+# BUILD_SHARED_LIBS=OFF for xcode needed
 set(MGE_SHARED_LIB megengine_shared)
-set(MGE_SHARED_LIB ${MGE_SHARED_LIB} PARENT_SCOPE)
+set(MGE_SHARED_LIB
+    ${MGE_SHARED_LIB}
+    PARENT_SCOPE)
 
 if(MGE_WITH_JIT_MLIR)
-    add_subdirectory(jit/include/megbrain/jit/mlir/ir)
+  add_subdirectory(jit/include/megbrain/jit/mlir/ir)
 endif()
 
-file(GLOB_RECURSE SOURCES core/impl/*.cpp gopt/impl/*.cpp opr/impl/*.cpp opr/impl/nvof/*.cpp plugin/impl/*.cpp serialization/impl/*.cpp core/impl/*.inl gopt/impl/*.inl opr/impl/*.inl plugin/impl/*.inl serialization/impl/*.inl)
-
+file(
+  GLOB_RECURSE
+  SOURCES
+  core/impl/*.cpp
+  gopt/impl/*.cpp
+  opr/impl/*.cpp
+  opr/impl/nvof/*.cpp
+  plugin/impl/*.cpp
+  serialization/impl/*.cpp
+  core/impl/*.inl
+  gopt/impl/*.inl
+  opr/impl/*.inl
+  plugin/impl/*.inl
+  serialization/impl/*.inl)
 
 if(MGE_WITH_JIT)
-    file(GLOB_RECURSE SOURCES_ jit/impl/*.cpp jit/impl/*.inl)
-    if(MGE_WITH_JIT_MLIR)
-        file(GLOB_RECURSE MLIR_SOURCES_ jit/impl/mlir/ir/*.cpp jit/impl/mlir/*.cpp)
-        list(APPEND SOURCES_ ${MLIR_SOURCES_})
-    endif()
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ jit/impl/*.cpp jit/impl/*.inl)
+  if(MGE_WITH_JIT_MLIR)
+    file(GLOB_RECURSE MLIR_SOURCES_ jit/impl/mlir/ir/*.cpp jit/impl/mlir/*.cpp)
+    list(APPEND SOURCES_ ${MLIR_SOURCES_})
+  endif()
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 if(MGE_WITH_DISTRIBUTED)
-    file(GLOB_RECURSE SOURCES_ opr-mm/impl/*.cpp opr-mm/impl/*.inl)
-    list(APPEND SOURCES ${SOURCES_})
-    file(GLOB_RECURSE PROTO_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "../src/opr-mm/proto/*.proto")
-    PROTOBUF_GENERATE_CPP_WITH_ROOT(GRPC_SRCS GRPC_HDRS ${CMAKE_CURRENT_SOURCE_DIR} ${PROTO_FILES})
-    add_custom_target(mgb_proto_target DEPENDS ${GRPC_SRCS} ${GRPC_HDRS} ${PROTOBUF_PROTOC_EXECUTABLE})
-    list(APPEND SOURCES ${GRPC_SRCS})
+  file(GLOB_RECURSE SOURCES_ opr-mm/impl/*.cpp opr-mm/impl/*.inl)
+  list(APPEND SOURCES ${SOURCES_})
+  file(
+    GLOB_RECURSE PROTO_FILES
+    RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+    "../src/opr-mm/proto/*.proto")
+  protobuf_generate_cpp_with_root(GRPC_SRCS GRPC_HDRS ${CMAKE_CURRENT_SOURCE_DIR}
+                                  ${PROTO_FILES})
+  add_custom_target(mgb_proto_target DEPENDS ${GRPC_SRCS} ${GRPC_HDRS}
+                                             ${PROTOBUF_PROTOC_EXECUTABLE})
+  list(APPEND SOURCES ${GRPC_SRCS})
 endif()
 
-set(MGB_INC ${PROJECT_BINARY_DIR}/genfiles ${CMAKE_CURRENT_LIST_DIR}/core/include ${CMAKE_CURRENT_LIST_DIR}/gopt/include ${CMAKE_CURRENT_LIST_DIR}/opr/include ${CMAKE_CURRENT_LIST_DIR}/plugin/include ${CMAKE_CURRENT_LIST_DIR}/serialization/include)
+set(MGB_INC
+    ${PROJECT_BINARY_DIR}/genfiles
+    ${CMAKE_CURRENT_LIST_DIR}/core/include
+    ${CMAKE_CURRENT_LIST_DIR}/gopt/include
+    ${CMAKE_CURRENT_LIST_DIR}/opr/include
+    ${CMAKE_CURRENT_LIST_DIR}/plugin/include
+    ${CMAKE_CURRENT_LIST_DIR}/serialization/include)
 
 if(MGE_WITH_JIT)
-    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/include)
-    if(MGE_WITH_CUDA)
-        list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/impl/cuda)
-    endif()
+  list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/include)
+  if(MGE_WITH_CUDA)
+    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/jit/impl/cuda)
+  endif()
 endif()
 
 if(MGE_WITH_DISTRIBUTED)
-    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/opr-mm/include)
+  list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/opr-mm/include)
 endif()
 
 if(MGE_WITH_CUDA AND MGE_WITH_TRT)
-    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/tensorrt/include)
-    file(GLOB_RECURSE SOURCES_ tensorrt/impl/*.cpp tensorrt/impl/*.inl)
-    list(APPEND SOURCES ${SOURCES_})
+  list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/tensorrt/include)
+  file(GLOB_RECURSE SOURCES_ tensorrt/impl/*.cpp tensorrt/impl/*.inl)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 if(MGE_WITH_CAMBRICON)
-    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/cambricon/include)
-    file(GLOB_RECURSE SOURCES_ cambricon/impl/*.cpp cambricon/impl/*.inl)
-    list(APPEND SOURCES ${SOURCES_})
+  list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/cambricon/include)
+  file(GLOB_RECURSE SOURCES_ cambricon/impl/*.cpp cambricon/impl/*.inl)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 set(MGB_CAMBRICON ${MGE_WITH_CAMBRICON})
 
 set(MGB_ATLAS ${MGE_WITH_ATLAS})
 
 if(MGE_WITH_CUDA)
-    file(GLOB_RECURSE SOURCES_ opr/impl/standalone/*.cu)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ opr/impl/standalone/*.cu)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 if(MGE_WITH_CUSTOM_OP)
-    list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/custom/include)
-    file(GLOB_RECURSE SOURCES_ custom/impl/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  list(APPEND MGB_INC ${CMAKE_CURRENT_LIST_DIR}/custom/include)
+  file(GLOB_RECURSE SOURCES_ custom/impl/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 add_library(megbrain OBJECT ${SOURCES})
 target_link_libraries(megbrain PUBLIC mgb_opr_param_defs)
 if(MGE_WITH_CUDA)
-    target_include_directories(megbrain PUBLIC ${TRT_INCLUDE_DIR})
-    target_include_directories(megbrain PRIVATE ${CUDNN_INCLUDE_DIR})
-    find_path(NVTX3_INCLUDE
-        NAMES nvToolsExtCudaRt.h
-        HINTS $ENV{CUDA_ROOT_DIR} $ENV{CUDA_PATH} $ENV{CUDA_BIN_PATH}
-        PATH_SUFFIXES include/nvtx3
-        DOC "NVTX3_INCLUDE" )
-    if(NVTX3_INCLUDE STREQUAL "NVTX3_INCLUDE-NOTFOUND")
-        message(FATAL_ERROR "Can not find NVTX3 INCLUDE, please export cuda sdk path to CUDA_ROOT_DIR or CUDA_PATH or CUDA_BIN_PATH")
-    endif()
-    target_include_directories(megbrain PRIVATE ${NVTX3_INCLUDE})
-endif()
-target_include_directories(megbrain
-    PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-    PRIVATE ${PROJECT_SOURCE_DIR}/third_party/midout/src
-)
-
-foreach (INCPATH IN LISTS MGB_INC)
-    target_include_directories(megbrain
-        PUBLIC $<BUILD_INTERFACE:${INCPATH}>
+  target_include_directories(megbrain PUBLIC ${TRT_INCLUDE_DIR})
+  target_include_directories(megbrain PRIVATE ${CUDNN_INCLUDE_DIR})
+  find_path(
+    NVTX3_INCLUDE
+    NAMES nvToolsExtCudaRt.h
+    HINTS $ENV{CUDA_ROOT_DIR} $ENV{CUDA_PATH} $ENV{CUDA_BIN_PATH}
+    PATH_SUFFIXES include/nvtx3
+    DOC "NVTX3_INCLUDE")
+  if(NVTX3_INCLUDE STREQUAL "NVTX3_INCLUDE-NOTFOUND")
+    message(
+      FATAL_ERROR
+        "Can not find NVTX3 INCLUDE, please export cuda sdk path to CUDA_ROOT_DIR or CUDA_PATH or CUDA_BIN_PATH"
     )
+  endif()
+  target_include_directories(megbrain PRIVATE ${NVTX3_INCLUDE})
+endif()
+target_include_directories(
+  megbrain
+  PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+  PRIVATE ${PROJECT_SOURCE_DIR}/third_party/midout/src)
+
+foreach(INCPATH IN LISTS MGB_INC)
+  target_include_directories(megbrain PUBLIC $<BUILD_INTERFACE:${INCPATH}>)
 endforeach()
 
 if(MGE_WITH_CUDA)
-    if(NOT WIN32 AND NOT MSVC)
-        target_compile_options(megbrain PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-unused-parameter>"
-            "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-unused-parameter>")
-    endif()
+  if(NOT WIN32 AND NOT MSVC)
+    target_compile_options(
+      megbrain PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-unused-parameter>"
+                       "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-unused-parameter>")
+  endif()
 else()
-    target_compile_options(megbrain PRIVATE "-Wno-unused-parameter")
+  target_compile_options(megbrain PRIVATE "-Wno-unused-parameter")
 endif()
 if(CXX_SUPPORT_WCLASS_MEMACCESS)
-    if(MGE_WITH_CUDA)
-        target_compile_options(megbrain PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
-            "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
-    else()
-        target_compile_options(megbrain PRIVATE "-Wno-class-memaccess")
-    endif()
+  if(MGE_WITH_CUDA)
+    target_compile_options(
+      megbrain PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
+                       "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
+  else()
+    target_compile_options(megbrain PRIVATE "-Wno-class-memaccess")
+  endif()
 endif()
 target_link_libraries(megbrain PUBLIC megdnn)
 if(MGE_WITH_DISTRIBUTED)
-    add_dependencies(megbrain mgb_proto_target)
-    target_link_libraries (megbrain PRIVATE libprotobuf libzmq)
-    set(CPPZMQ_INC ${PROJECT_SOURCE_DIR}/third_party/cppzmq)
-    # FIXME: add CMAKE_CURRENT_BINARY_DIR for including mm_handler.pb.h
-    target_include_directories(megbrain PRIVATE ${CPPZMQ_INC} ${CMAKE_CURRENT_BINARY_DIR})
-    target_link_libraries (megbrain PRIVATE megray)
+  add_dependencies(megbrain mgb_proto_target)
+  target_link_libraries(megbrain PRIVATE libprotobuf libzmq)
+  set(CPPZMQ_INC ${PROJECT_SOURCE_DIR}/third_party/cppzmq)
+  # FIXME: add CMAKE_CURRENT_BINARY_DIR for including mm_handler.pb.h
+  target_include_directories(megbrain PRIVATE ${CPPZMQ_INC} ${CMAKE_CURRENT_BINARY_DIR})
+  target_link_libraries(megbrain PRIVATE megray)
 endif()
 target_link_libraries(megbrain PUBLIC ${MGE_CAMBRICON_LIBS})
 target_link_libraries(megbrain PUBLIC ${MGE_ATLAS_LIBS})
 if(MGE_WITH_JIT AND MGE_WITH_HALIDE)
-    target_link_libraries(megbrain PRIVATE libhalide)
-    target_link_libraries(megbrain PRIVATE ${HALIDE_LLVM_LIBS})
+  target_link_libraries(megbrain PRIVATE libhalide)
+  target_link_libraries(megbrain PRIVATE ${HALIDE_LLVM_LIBS})
 endif()
 if(MGE_WITH_JIT_MLIR)
-    target_include_directories(megbrain PRIVATE ${MLIR_LLVM_INCLUDE_DIR})
-    target_link_libraries(megbrain PRIVATE ${MLIR_LLVM_LIBS})
-    add_dependencies(megbrain mgb_dialect)
-    target_include_directories(megbrain PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/jit/include)
-endif()
-if (MGB_WITH_FLATBUFFERS)
-    set (GEN_FLATBUFFERS_SCHEMA_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_schema.py)
-    set (OPR_PARAM_DEFS_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/opr_param_defs.py)
-    set (MGB_PARAM_DEFS_PY ${PROJECT_SOURCE_DIR}/tools/param_defs/mgb_opr_param_defs.py)
-    file (MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl)
-    add_custom_command(
-        OUTPUT
+  target_include_directories(megbrain PRIVATE ${MLIR_LLVM_INCLUDE_DIR})
+  target_link_libraries(megbrain PRIVATE ${MLIR_LLVM_LIBS})
+  add_dependencies(megbrain mgb_dialect)
+  target_include_directories(megbrain PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/jit/include)
+endif()
+if(MGB_WITH_FLATBUFFERS)
+  set(GEN_FLATBUFFERS_SCHEMA_PY
+      ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_schema.py)
+  set(OPR_PARAM_DEFS_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/opr_param_defs.py)
+  set(MGB_PARAM_DEFS_PY ${PROJECT_SOURCE_DIR}/tools/param_defs/mgb_opr_param_defs.py)
+  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl)
+  add_custom_command(
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/opr_param_defs.fbs
+    COMMAND ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_SCHEMA_PY} ${OPR_PARAM_DEFS_PY}
             ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/opr_param_defs.fbs
-        COMMAND
-            ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_SCHEMA_PY} ${OPR_PARAM_DEFS_PY} ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/opr_param_defs.fbs
-        DEPENDS ${GEN_FLATBUFFERS_SCHEMA_PY} ${OPR_PARAM_DEFS_PY}
-        VERBATIM
-    )
-    add_custom_command(
-        OUTPUT
+    DEPENDS ${GEN_FLATBUFFERS_SCHEMA_PY} ${OPR_PARAM_DEFS_PY}
+    VERBATIM)
+  add_custom_command(
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/mgb_opr_param_defs.fbs
+    COMMAND ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_SCHEMA_PY} ${MGB_PARAM_DEFS_PY}
             ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/mgb_opr_param_defs.fbs
-        COMMAND
-            ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_SCHEMA_PY} ${MGB_PARAM_DEFS_PY} ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/mgb_opr_param_defs.fbs
-        DEPENDS ${GEN_FLATBUFFERS_SCHEMA_PY} ${MGB_PARAM_DEFS_PY}
-        VERBATIM
-    )
-    list(APPEND FLATBUFFERS_SCHEMA_FILES
-        ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl/dtype.fbs
-        ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/opr_param_defs.fbs
-        ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/mgb_opr_param_defs.fbs
-        ${CMAKE_CURRENT_SOURCE_DIR}/opr/impl/mgb_cpp_opr.fbs
-        ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl/schema.fbs
-    )
-    list(APPEND FLATBUFFERS_SCHEMA_INCLUDE_DIR
-        ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl
-        ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl
-        ${CMAKE_CURRENT_SOURCE_DIR}/opr/impl
-    )
-    build_flatbuffers(
-        "${FLATBUFFERS_SCHEMA_FILES}"
-        "${FLATBUFFERS_SCHEMA_INCLUDE_DIR}"
-        mgb_serialization_schema_fbs
-        "${FLATBUFFERS_SCHEMA_FILES}"
-        "${CMAKE_CURRENT_BINARY_DIR}/serialization/include/megbrain/serialization/internal"
-        ""
-        ""
-    )
-    add_dependencies(megbrain mgb_serialization_schema_fbs)
-    target_include_directories(megbrain PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/serialization/include)
-    target_compile_definitions(megbrain PUBLIC MGB_ENABLE_FBS_SERIALIZATION=1)
-    target_link_libraries(megbrain PUBLIC flatbuffers)
-    set (GENERATED_FLATBUFFERS_CONVERTER_PATH ${CMAKE_CURRENT_BINARY_DIR}/genfiles)
-    set (GEN_FLATBUFFERS_CONVERTER_PY ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_converter.py)
-    file (MAKE_DIRECTORY ${GENERATED_FLATBUFFERS_CONVERTER_PATH})
-    add_custom_command(
-        OUTPUT
+    DEPENDS ${GEN_FLATBUFFERS_SCHEMA_PY} ${MGB_PARAM_DEFS_PY}
+    VERBATIM)
+  list(
+    APPEND
+    FLATBUFFERS_SCHEMA_FILES
+    ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl/dtype.fbs
+    ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/opr_param_defs.fbs
+    ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl/mgb_opr_param_defs.fbs
+    ${CMAKE_CURRENT_SOURCE_DIR}/opr/impl/mgb_cpp_opr.fbs
+    ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl/schema.fbs)
+  list(
+    APPEND FLATBUFFERS_SCHEMA_INCLUDE_DIR
+    ${CMAKE_CURRENT_SOURCE_DIR}/serialization/impl
+    ${CMAKE_CURRENT_BINARY_DIR}/serialization/impl ${CMAKE_CURRENT_SOURCE_DIR}/opr/impl)
+  build_flatbuffers(
+    "${FLATBUFFERS_SCHEMA_FILES}"
+    "${FLATBUFFERS_SCHEMA_INCLUDE_DIR}"
+    mgb_serialization_schema_fbs
+    "${FLATBUFFERS_SCHEMA_FILES}"
+    "${CMAKE_CURRENT_BINARY_DIR}/serialization/include/megbrain/serialization/internal"
+    ""
+    "")
+  add_dependencies(megbrain mgb_serialization_schema_fbs)
+  target_include_directories(megbrain
+                             PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/serialization/include)
+  target_compile_definitions(megbrain PUBLIC MGB_ENABLE_FBS_SERIALIZATION=1)
+  target_link_libraries(megbrain PUBLIC flatbuffers)
+  set(GENERATED_FLATBUFFERS_CONVERTER_PATH ${CMAKE_CURRENT_BINARY_DIR}/genfiles)
+  set(GEN_FLATBUFFERS_CONVERTER_PY
+      ${PROJECT_SOURCE_DIR}/dnn/scripts/gen_flatbuffers_converter.py)
+  file(MAKE_DIRECTORY ${GENERATED_FLATBUFFERS_CONVERTER_PATH})
+  add_custom_command(
+    OUTPUT ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/opr_param_defs_converter.inl
+    COMMAND ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_CONVERTER_PY} ${OPR_PARAM_DEFS_PY}
             ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/opr_param_defs_converter.inl
-        COMMAND
-            ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_CONVERTER_PY} ${OPR_PARAM_DEFS_PY} ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/opr_param_defs_converter.inl
-        DEPENDS ${GEN_FLATBUFFERS_CONVERTER_PY} ${OPR_PARAM_DEFS_PY}
-        VERBATIM
-    )
-    add_custom_command(
-        OUTPUT
+    DEPENDS ${GEN_FLATBUFFERS_CONVERTER_PY} ${OPR_PARAM_DEFS_PY}
+    VERBATIM)
+  add_custom_command(
+    OUTPUT ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/mgb_opr_param_defs_converter.inl
+    COMMAND ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_CONVERTER_PY} ${MGB_PARAM_DEFS_PY}
             ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/mgb_opr_param_defs_converter.inl
-        COMMAND
-            ${PYTHON_EXECUTABLE} ${GEN_FLATBUFFERS_CONVERTER_PY} ${MGB_PARAM_DEFS_PY} ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/mgb_opr_param_defs_converter.inl
-        DEPENDS ${GEN_FLATBUFFERS_CONVERTER_PY} ${MGB_PARAM_DEFS_PY}
-        VERBATIM
-    )
-    target_sources(megbrain PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/opr_param_defs_converter.inl)
-    target_sources(megbrain PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/mgb_opr_param_defs_converter.inl)
-    target_include_directories(megbrain PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH})
+    DEPENDS ${GEN_FLATBUFFERS_CONVERTER_PY} ${MGB_PARAM_DEFS_PY}
+    VERBATIM)
+  target_sources(
+    megbrain
+    PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/opr_param_defs_converter.inl)
+  target_sources(
+    megbrain
+    PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH}/mgb_opr_param_defs_converter.inl)
+  target_include_directories(megbrain PRIVATE ${GENERATED_FLATBUFFERS_CONVERTER_PATH})
 endif()
-if(UNIX AND NOT ANDROID AND NOT APPLE)
-    target_link_libraries(megbrain PUBLIC dl rt atomic)
+if(UNIX
+   AND NOT ANDROID
+   AND NOT APPLE)
+  target_link_libraries(megbrain PUBLIC dl rt atomic)
 endif()
 
 if(ANDROID)
-    target_link_libraries(megbrain PUBLIC log)
+  target_link_libraries(megbrain PUBLIC log)
 endif()
 
-set (_VER_FILE ${PROJECT_SOURCE_DIR}/src/version.ld)
+set(_VER_FILE ${PROJECT_SOURCE_DIR}/src/version.ld)
 
 # Build as SHARED or STATIC depending on BUILD_SHARED_LIBS=ON/OFF
 add_library(megengine)
@@ -216,39 +245,44 @@ target_link_libraries(megengine PRIVATE ${MGE_CUDA_LIBS})
 target_link_libraries(megengine PUBLIC megbrain megdnn)
 target_link_libraries(${MGE_SHARED_LIB} PUBLIC megbrain megdnn)
 target_link_libraries(${MGE_SHARED_LIB} PRIVATE ${MGE_CUDA_LIBS})
-if (UNIX AND NOT APPLE)
-    target_link_options(megengine PRIVATE -Wl,--no-undefined -Wl,--version-script=${_VER_FILE})
-    set_target_properties(megengine PROPERTIES LINK_DEPENDS ${_VER_FILE})
-    target_link_options(${MGE_SHARED_LIB} PRIVATE -Wl,--no-undefined -Wl,--version-script=${_VER_FILE})
-    set_target_properties(${MGE_SHARED_LIB} PROPERTIES LINK_DEPENDS ${_VER_FILE})
+if(UNIX AND NOT APPLE)
+  target_link_options(megengine PRIVATE -Wl,--no-undefined
+                      -Wl,--version-script=${_VER_FILE})
+  set_target_properties(megengine PROPERTIES LINK_DEPENDS ${_VER_FILE})
+  target_link_options(${MGE_SHARED_LIB} PRIVATE -Wl,--no-undefined
+                      -Wl,--version-script=${_VER_FILE})
+  set_target_properties(${MGE_SHARED_LIB} PROPERTIES LINK_DEPENDS ${_VER_FILE})
 endif()
 if(WIN32 OR MSVC)
-    target_compile_definitions(megbrain PRIVATE MGE_DLL_EXPORT)
-    target_compile_definitions(megdnn PRIVATE MGE_DLL_EXPORT)
-    target_compile_definitions(megengine PRIVATE MGE_DLL_EXPORT)
-    target_compile_definitions(${MGE_SHARED_LIB} PRIVATE MGE_DLL_EXPORT)
-    # please do not use WINDOWS_EXPORT_ALL_SYMBOLS, as symbols max than 65535 when build with CUDA
-    #set_target_properties(megengine PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
-    #set_target_properties(${MGE_SHARED_LIB} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
-endif()
-if (MGE_WITH_DISTRIBUTED)
-    message(VERBOSE "megengine configured to link megray")
-    target_link_libraries(megengine PUBLIC megray)
-    target_link_libraries(${MGE_SHARED_LIB} PUBLIC megray)
-endif()
-# Do not export targets if MGE_WITH_DISTRIBUTED is on. MegRay is not ready
-# for this.
-install(TARGETS megengine
-    EXPORT ${MGE_EXPORT_TARGETS}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
-
-if (NOT MGE_WITH_DISTRIBUTED)
-    install(TARGETS megbrain
-            EXPORT ${MGE_EXPORT_TARGETS}
-            )
+  target_compile_definitions(megbrain PRIVATE MGE_DLL_EXPORT)
+  target_compile_definitions(megdnn PRIVATE MGE_DLL_EXPORT)
+  target_compile_definitions(megengine PRIVATE MGE_DLL_EXPORT)
+  target_compile_definitions(${MGE_SHARED_LIB} PRIVATE MGE_DLL_EXPORT)
+  # please do not use WINDOWS_EXPORT_ALL_SYMBOLS, as symbols max than 65535 when build
+  # with CUDA set_target_properties(megengine PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS
+  # TRUE) set_target_properties(${MGE_SHARED_LIB} PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS
+  # TRUE)
+endif()
+if(MGE_WITH_DISTRIBUTED)
+  message(VERBOSE "megengine configured to link megray")
+  target_link_libraries(megengine PUBLIC megray)
+  target_link_libraries(${MGE_SHARED_LIB} PUBLIC megray)
+endif()
+# Do not export targets if MGE_WITH_DISTRIBUTED is on. MegRay is not ready for this.
+install(
+  TARGETS megengine
+  EXPORT ${MGE_EXPORT_TARGETS}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+if(NOT MGE_WITH_DISTRIBUTED)
+  install(TARGETS megbrain EXPORT ${MGE_EXPORT_TARGETS})
 endif()
 
 foreach(_PATH ${MGB_INC})
-    install(DIRECTORY ${_PATH}/megbrain DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
+  install(
+    DIRECTORY ${_PATH}/megbrain
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    FILES_MATCHING
+    PATTERN "*.h")
 endforeach()

src/jit/test/mlir/CMakeLists.txt

@@ -1,27 +1,20 @@
 configure_lit_site_cfg(
-        ${CMAKE_CURRENT_SOURCE_DIR}/utils/lit.site.cfg.py.in
-        ${CMAKE_CURRENT_BINARY_DIR}/utils/lit.site.cfg.py
-        MAIN_CONFIG
-        ${CMAKE_CURRENT_SOURCE_DIR}/utils/lit.cfg.py
-)
+  ${CMAKE_CURRENT_SOURCE_DIR}/utils/lit.site.cfg.py.in
+  ${CMAKE_CURRENT_BINARY_DIR}/utils/lit.site.cfg.py MAIN_CONFIG
+  ${CMAKE_CURRENT_SOURCE_DIR}/utils/lit.cfg.py)
 
-set(LLVM_EXTERNAL_LIT "${PROJECT_SOURCE_DIR}/third_party/llvm-project/llvm/utils/lit/lit.py" CACHE STRING "External lit")
+set(LLVM_EXTERNAL_LIT
+    "${PROJECT_SOURCE_DIR}/third_party/llvm-project/llvm/utils/lit/lit.py"
+    CACHE STRING "External lit")
 
-set(MLIR_MGB_TEST_DEPENDS
-        mgb-file-check
-        count not
-        mgb-opt
-)
+set(MLIR_MGB_TEST_DEPENDS mgb-file-check count not mgb-opt)
 
 add_lit_testsuite(mgb-mlir-test-lit "Running the mgb regression tests"
-        ${CMAKE_CURRENT_BINARY_DIR}/utils
-        DEPENDS ${MLIR_MGB_TEST_DEPENDS}
-        )
+                  ${CMAKE_CURRENT_BINARY_DIR}/utils DEPENDS ${MLIR_MGB_TEST_DEPENDS})
 set_target_properties(mgb-mlir-test-lit PROPERTIES FOLDER "Tests")
 
-add_lit_testsuites(MLIR_TEST ${CMAKE_CURRENT_SOURCE_DIR} 
-        DEPENDS ${MLIR_MGB_TEST_DEPENDS}
-)
+add_lit_testsuites(MLIR_TEST ${CMAKE_CURRENT_SOURCE_DIR} DEPENDS
+                   ${MLIR_MGB_TEST_DEPENDS})
 
 add_custom_target(mlir_pass_check)
 add_dependencies(mlir_pass_check mgb-mlir-test-lit)

test/CMakeLists.txt

@@ -1,52 +1,63 @@
 include_directories("./src/include")
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-parameter")
-file(GLOB_RECURSE SOURCES ./*.cpp ../src/core/test/*.cpp ../src/gopt/test/*.cpp ../src/opr/test/*.cpp ../src/plugin/test/*.cpp ../src/serialization/test/*.cpp)
+file(
+  GLOB_RECURSE
+  SOURCES
+  ./*.cpp
+  ../src/core/test/*.cpp
+  ../src/gopt/test/*.cpp
+  ../src/opr/test/*.cpp
+  ../src/plugin/test/*.cpp
+  ../src/serialization/test/*.cpp)
 if(MGE_WITH_JIT)
-    file(GLOB_RECURSE SOURCES_ ../src/jit/test/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ ../src/jit/test/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 if(MGE_WITH_DISTRIBUTED)
-    file(GLOB_RECURSE SOURCES_ ../src/opr-mm/test/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+  file(GLOB_RECURSE SOURCES_ ../src/opr-mm/test/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
-if (MGE_WITH_CUDA AND MGE_WITH_TRT)
-    file(GLOB_RECURSE SOURCES_ ../src/tensorrt/test/*.cpp)
-    list(APPEND SOURCES ${SOURCES_})
+if(MGE_WITH_CUDA AND MGE_WITH_TRT)
+  file(GLOB_RECURSE SOURCES_ ../src/tensorrt/test/*.cpp)
+  list(APPEND SOURCES ${SOURCES_})
 endif()
 
 add_executable(megbrain_test ${SOURCES})
 if(WIN32 OR MSVC)
-    target_compile_definitions(megbrain_test PRIVATE MGE_WINDOWS_STATIC_LINK)
+  target_compile_definitions(megbrain_test PRIVATE MGE_WINDOWS_STATIC_LINK)
 endif()
 target_link_libraries(megbrain_test gtest gmock)
 target_link_libraries(megbrain_test megbrain megdnn ${MGE_CUDA_LIBS})
-if (MGE_WITH_CUDA)
-    target_include_directories(megbrain_test PRIVATE ${CUDNN_INCLUDE_DIR})
+if(MGE_WITH_CUDA)
+  target_include_directories(megbrain_test PRIVATE ${CUDNN_INCLUDE_DIR})
 endif()
 if(CXX_SUPPORT_WCLASS_MEMACCESS)
-    if(MGE_WITH_CUDA)
-        target_compile_options(megbrain_test PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
-            "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
-    else()
-        target_compile_options(megbrain_test PRIVATE "-Wno-class-memaccess")
-    endif()
+  if(MGE_WITH_CUDA)
+    target_compile_options(
+      megbrain_test
+      PRIVATE "$<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wno-class-memaccess>"
+              "$<$<NOT:$<COMPILE_LANGUAGE:CUDA>>:-Wno-class-memaccess>")
+  else()
+    target_compile_options(megbrain_test PRIVATE "-Wno-class-memaccess")
+  endif()
 endif()
 
 if(UNIX)
-    if(APPLE OR ANDROID)
-        target_link_libraries(megbrain_test dl)
-    else()
-        target_link_libraries(megbrain_test dl rt)
-    endif()
+  if(APPLE OR ANDROID)
+    target_link_libraries(megbrain_test dl)
+  else()
+    target_link_libraries(megbrain_test dl rt)
+  endif()
 endif()
 
-if (MGE_WITH_DISTRIBUTED)
-    target_link_libraries(megbrain_test megray)
+if(MGE_WITH_DISTRIBUTED)
+  target_link_libraries(megbrain_test megray)
 endif()
 
 if(MGE_WITH_JIT)
-    if(MGE_WITH_JIT_MLIR)
-        add_subdirectory(${PROJECT_SOURCE_DIR}/src/jit/test/mlir ${CMAKE_CURRENT_BINARY_DIR}/../src/jit/test/mlir)
-    endif()
+  if(MGE_WITH_JIT_MLIR)
+    add_subdirectory(${PROJECT_SOURCE_DIR}/src/jit/test/mlir
+                     ${CMAKE_CURRENT_BINARY_DIR}/../src/jit/test/mlir)
+  endif()
 endif()

toolchains/aarch64-linux-gnu.toolchain.cmake

@@ -2,8 +2,8 @@ set(ARM_CROSS_BUILD_ARCH aarch64)
 set(CMAKE_C_COMPILER "aarch64-linux-gnu-gcc")
 set(CMAKE_CXX_COMPILER "aarch64-linux-gnu-g++")
 if("$ENV{FORCE_CHECK_UNUSED_PARAMETER}" STREQUAL "true")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
 endif()
 set(CMAKE_STRIP "aarch64-linux-gnu-strip")
 set(CMAKE_SYSTEM_PROCESSOR aarch64)

toolchains/aarch64-none-linux-gnu.toolchain.cmake

@@ -4,8 +4,8 @@ set(CMAKE_CXX_COMPILER "aarch64-none-linux-gnu-g++")
 set(CMAKE_C_FLAGS "-Wno-psabi")
 set(CMAKE_CXX_FLAGS "-Wno-psabi")
 if("$ENV{FORCE_CHECK_UNUSED_PARAMETER}" STREQUAL "true")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
 endif()
 set(CMAKE_STRIP "aarch64-none-linux-gnu-strip")
 set(CMAKE_SYSTEM_PROCESSOR aarch64)

toolchains/arm-linux-gnueabi.toolchain.cmake

@@ -4,8 +4,8 @@ set(CMAKE_CXX_COMPILER "arm-linux-gnueabi-g++")
 set(CMAKE_C_FLAGS "-mfloat-abi=softfp -mfpu=neon-vfpv4 -Wno-psabi")
 set(CMAKE_CXX_FLAGS "-mfloat-abi=softfp -mfpu=neon-vfpv4 -Wno-psabi")
 if("$ENV{FORCE_CHECK_UNUSED_PARAMETER}" STREQUAL "true")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
 endif()
 set(CMAKE_STRIP "arm-linux-gnueabi-strip")
 set(CMAKE_SYSTEM_PROCESSOR armv7)

toolchains/arm-linux-gnueabihf.toolchain.cmake

@@ -4,8 +4,8 @@ set(CMAKE_CXX_COMPILER "arm-linux-gnueabihf-g++")
 set(CMAKE_C_FLAGS "-mfloat-abi=hard -mfpu=neon-vfpv4 -Wno-psabi")
 set(CMAKE_CXX_FLAGS "-mfloat-abi=hard -mfpu=neon-vfpv4 -Wno-psabi")
 if("$ENV{FORCE_CHECK_UNUSED_PARAMETER}" STREQUAL "true")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=unused-parameter")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror=unused-parameter")
 endif()
 set(CMAKE_STRIP "arm-linux-gnueabihf-strip")
 set(CMAKE_SYSTEM_PROCESSOR armv7)

toolchains/ios.toolchain.cmake

@@ -1,103 +1,87 @@
 # This file is part of the ios-cmake project. It was retrieved from
 # https://github.com/cristeab/ios-cmake.git, which is a fork of
-# https://code.google.com/p/ios-cmake/. Which in turn is based off of
-# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which
-# are included with CMake 2.8.4
+# https://code.google.com/p/ios-cmake/. Which in turn is based off of the
+# Platform/Darwin.cmake and Platform/UnixPaths.cmake files which are included with CMake
+# 2.8.4
 #
 # The ios-cmake project is licensed under the new BSD license.
 #
-# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software,
-# Kitware, Inc., Insight Software Consortium.  All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1. Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
+# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software, Kitware, Inc.,
+# Insight Software Consortium.  All rights reserved. Redistribution and use in source
+# and binary forms, with or without modification, are permitted provided that the
+# following conditions are met: 1. Redistributions of source code must retain the above
+# copyright notice, this list of conditions and the following disclaimer.
 #
-# 2. Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
+# 1. Redistributions in binary form must reproduce the above copyright notice, this list
+#   of conditions and the following disclaimer in the documentation and/or other
+#   materials provided with the distribution.
 #
-# 3. Neither the name of the copyright holder nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
+# 1. Neither the name of the copyright holder nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without specific
+#   prior written permission.
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+# SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+# BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+# WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+# DAMAGE.
 #
-# This file is based off of the Platform/Darwin.cmake and
-# Platform/UnixPaths.cmake files which are included with CMake 2.8.4
-# It has been altered for iOS development.
+# This file is based off of the Platform/Darwin.cmake and Platform/UnixPaths.cmake files
+# which are included with CMake 2.8.4 It has been altered for iOS development.
 #
 # Updated by Alex Stewart (alexs.mac@gmail.com)
 #
 # *****************************************************************************
-#      Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com)
-#                      under the BSD-3-Clause license
-#                   https://github.com/leetal/ios-cmake
+# Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com) under the
+# BSD-3-Clause license https://github.com/leetal/ios-cmake
 # *****************************************************************************
 #
-#                           INFORMATION / HELP
+# INFORMATION / HELP
 #
 # The following variables control the behaviour of this toolchain:
 #
-# IOS_PLATFORM: OS (default) or SIMULATOR or SIMULATOR64 or TVOS or SIMULATOR_TVOS or WATCHOS or SIMULATOR_WATCHOS
-#    OS = Build for iPhoneOS.
-#    OS64 = Build for arm64 arm64e iPhoneOS.
-#    SIMULATOR = Build for x86 i386 iPhone Simulator.
-#    SIMULATOR64 = Build for x86_64 iPhone Simulator.
-#    TVOS = Build for AppleTVOS.
-#    SIMULATOR_TVOS = Build for x86_64 AppleTV Simulator.
-#    WATCHOS = Build for armv7k arm64_32 for WatchOS.
-#    SIMULATOR_WATCHOS = Build for x86_64 for Watch Simulator.
-# CMAKE_OSX_SYSROOT: Path to the iOS SDK to use.  By default this is
-#    automatically determined from IOS_PLATFORM and xcodebuild, but
-#    can also be manually specified (although this should not be required).
-# CMAKE_IOS_DEVELOPER_ROOT: Path to the Developer directory for the iOS platform
-#    being compiled for.  By default this is automatically determined from
-#    CMAKE_OSX_SYSROOT, but can also be manually specified (although this should
-#    not be required).
-# ENABLE_BITCODE: (1|0) Enables or disables bitcode support. Default 1 (true)
-# ENABLE_ARC: (1|0) Enables or disables ARC support. Default 1 (true, ARC enabled by default)
-# ENABLE_VISIBILITY: (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility hidden by default)
-# IOS_ARCH: (armv7 armv7s armv7k arm64 arm64e arm64_32 i386 x86_64) If specified, will override the default architectures for the given IOS_PLATFORM
-#    OS = armv7 armv7s arm64 arm64e (if applicable)
-#    OS64 = arm64 arm64e (if applicable)
-#    SIMULATOR = i386 x86_64
-#    SIMULATOR64 = x86_64
-#    TVOS = arm64
-#    SIMULATOR_TVOS = x86_64 (i386 has since long been deprecated)
-#    WATCHOS = armv7k arm64_32 (if applicable)
-#    SIMULATOR_WATCHOS = x86_64 (i386 has since long been deprecated)
+# IOS_PLATFORM: OS (default) or SIMULATOR or SIMULATOR64 or TVOS or SIMULATOR_TVOS or
+# WATCHOS or SIMULATOR_WATCHOS OS = Build for iPhoneOS. OS64 = Build for arm64 arm64e
+# iPhoneOS. SIMULATOR = Build for x86 i386 iPhone Simulator. SIMULATOR64 = Build for
+# x86_64 iPhone Simulator. TVOS = Build for AppleTVOS. SIMULATOR_TVOS = Build for x86_64
+# AppleTV Simulator. WATCHOS = Build for armv7k arm64_32 for WatchOS. SIMULATOR_WATCHOS
+# = Build for x86_64 for Watch Simulator. CMAKE_OSX_SYSROOT: Path to the iOS SDK to use.
+# By default this is automatically determined from IOS_PLATFORM and xcodebuild, but can
+# also be manually specified (although this should not be required).
+# CMAKE_IOS_DEVELOPER_ROOT: Path to the Developer directory for the iOS platform being
+# compiled for.  By default this is automatically determined from CMAKE_OSX_SYSROOT, but
+# can also be manually specified (although this should not be required). ENABLE_BITCODE:
+# (1|0) Enables or disables bitcode support. Default 1 (true) ENABLE_ARC: (1|0) Enables
+# or disables ARC support. Default 1 (true, ARC enabled by default) ENABLE_VISIBILITY:
+# (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility
+# hidden by default) IOS_ARCH: (armv7 armv7s armv7k arm64 arm64e arm64_32 i386 x86_64)
+# If specified, will override the default architectures for the given IOS_PLATFORM OS =
+# armv7 armv7s arm64 arm64e (if applicable) OS64 = arm64 arm64e (if applicable)
+# SIMULATOR = i386 x86_64 SIMULATOR64 = x86_64 TVOS = arm64 SIMULATOR_TVOS = x86_64
+# (i386 has since long been deprecated) WATCHOS = armv7k arm64_32 (if applicable)
+# SIMULATOR_WATCHOS = x86_64 (i386 has since long been deprecated)
 #
 # This toolchain defines the following variables for use externally:
 #
 # XCODE_VERSION: Version number (not including Build version) of Xcode detected.
-# IOS_SDK_VERSION: Version of iOS SDK being used.
-# CMAKE_OSX_ARCHITECTURES: Architectures being compiled for (generated from
-#    IOS_PLATFORM).
+# IOS_SDK_VERSION: Version of iOS SDK being used. CMAKE_OSX_ARCHITECTURES: Architectures
+# being compiled for (generated from IOS_PLATFORM).
 #
 # This toolchain defines the following macros for use externally:
 #
-# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT)
-#   A convenience macro for setting xcode specific properties on targets.
-#   Available variants are: All, Release, RelWithDebInfo, Debug, MinSizeRel
-#   example: set_xcode_property (myioslib IPHONEOS_DEPLOYMENT_TARGET "3.1" "all").
+# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT) A convenience
+# macro for setting xcode specific properties on targets. Available variants are: All,
+# Release, RelWithDebInfo, Debug, MinSizeRel example: set_xcode_property (myioslib
+# IPHONEOS_DEPLOYMENT_TARGET "3.1" "all").
 #
-# find_host_package (PROGRAM ARGS)
-#   A macro used to find executable programs on the host system, not within the
-#   iOS environment.  Thanks to the android-cmake project for providing the
-#   command.
+# find_host_package (PROGRAM ARGS) A macro used to find executable programs on the host
+# system, not within the iOS environment.  Thanks to the android-cmake project for
+# providing the command.
 
 # Fix for PThread library not in path
 set(CMAKE_THREAD_LIBS_INIT "-lpthread")
@@ -106,57 +90,58 @@ set(CMAKE_USE_WIN32_THREADS_INIT 0)
 set(CMAKE_USE_PTHREADS_INIT 1)
 
 # Get the Xcode version being used.
-execute_process(COMMAND xcodebuild -version
+execute_process(
+  COMMAND xcodebuild -version
   OUTPUT_VARIABLE XCODE_VERSION
-  ERROR_QUIET
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}")
 string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}")
 message(STATUS "Building with Xcode version: ${XCODE_VERSION}")
-# Default to building for iPhoneOS if not specified otherwise, and we cannot
-# determine the platform from the CMAKE_OSX_ARCHITECTURES variable. The use
-# of CMAKE_OSX_ARCHITECTURES is such that try_compile() projects can correctly
-# determine the value of IOS_PLATFORM from the root project, as
-# CMAKE_OSX_ARCHITECTURES is propagated to them by CMake.
-if (NOT DEFINED IOS_PLATFORM)
-  if (CMAKE_OSX_ARCHITECTURES)
-    if (CMAKE_OSX_ARCHITECTURES MATCHES ".*arm.*")
+# Default to building for iPhoneOS if not specified otherwise, and we cannot determine
+# the platform from the CMAKE_OSX_ARCHITECTURES variable. The use of
+# CMAKE_OSX_ARCHITECTURES is such that try_compile() projects can correctly determine
+# the value of IOS_PLATFORM from the root project, as CMAKE_OSX_ARCHITECTURES is
+# propagated to them by CMake.
+if(NOT DEFINED IOS_PLATFORM)
+  if(CMAKE_OSX_ARCHITECTURES)
+    if(CMAKE_OSX_ARCHITECTURES MATCHES ".*arm.*")
       set(IOS_PLATFORM "OS")
-    elseif (CMAKE_OSX_ARCHITECTURES MATCHES "i386")
+    elseif(CMAKE_OSX_ARCHITECTURES MATCHES "i386")
       set(IOS_PLATFORM "SIMULATOR")
-    elseif (CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+    elseif(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
       set(IOS_PLATFORM "SIMULATOR64")
-    elseif (CMAKE_OSX_ARCHITECTURES MATCHES "armv7k")
+    elseif(CMAKE_OSX_ARCHITECTURES MATCHES "armv7k")
       set(IOS_PLATFORM "WATCHOS")
     endif()
   endif()
-  if (NOT IOS_PLATFORM)
+  if(NOT IOS_PLATFORM)
     set(IOS_PLATFORM "OS")
   endif()
 endif()
-set(IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING
-  "Type of iOS platform for which to build.")
-# Determine the platform name and architectures for use in xcodebuild commands
-# from the specified IOS_PLATFORM name.
-if (IOS_PLATFORM STREQUAL "OS")
+set(IOS_PLATFORM
+    ${IOS_PLATFORM}
+    CACHE STRING "Type of iOS platform for which to build.")
+# Determine the platform name and architectures for use in xcodebuild commands from the
+# specified IOS_PLATFORM name.
+if(IOS_PLATFORM STREQUAL "OS")
   set(XCODE_IOS_PLATFORM iphoneos)
   if(NOT IOS_ARCH)
-    if (XCODE_VERSION VERSION_GREATER 10.0)
+    if(XCODE_VERSION VERSION_GREATER 10.0)
       set(IOS_ARCH armv7 armv7s arm64 arm64e)
     else()
       set(IOS_ARCH armv7 armv7s arm64)
     endif()
   endif()
- elseif (IOS_PLATFORM STREQUAL "OS64")
+elseif(IOS_PLATFORM STREQUAL "OS64")
   set(XCODE_IOS_PLATFORM iphoneos)
   if(NOT IOS_ARCH)
-    if (XCODE_VERSION VERSION_GREATER 10.0)
+    if(XCODE_VERSION VERSION_GREATER 10.0)
       set(IOS_ARCH arm64 arm64e)
     else()
       set(IOS_ARCH arm64)
     endif()
   endif()
-elseif (IOS_PLATFORM STREQUAL "SIMULATOR")
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR")
   set(XCODE_IOS_PLATFORM iphonesimulator)
   if(NOT IOS_ARCH)
     set(IOS_ARCH i386 x86_64)
@@ -166,26 +151,26 @@ elseif(IOS_PLATFORM STREQUAL "SIMULATOR64")
   if(NOT IOS_ARCH)
     set(IOS_ARCH x86_64)
   endif()
-elseif (IOS_PLATFORM STREQUAL "TVOS")
+elseif(IOS_PLATFORM STREQUAL "TVOS")
   set(XCODE_IOS_PLATFORM appletvos)
   if(NOT IOS_ARCH)
     set(IOS_ARCH arm64)
   endif()
-elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
   set(XCODE_IOS_PLATFORM appletvsimulator)
   if(NOT IOS_ARCH)
     set(IOS_ARCH x86_64)
   endif()
-elseif (IOS_PLATFORM STREQUAL "WATCHOS")
+elseif(IOS_PLATFORM STREQUAL "WATCHOS")
   set(XCODE_IOS_PLATFORM watchos)
   if(NOT IOS_ARCH)
-    if (XCODE_VERSION VERSION_GREATER 10.0)
+    if(XCODE_VERSION VERSION_GREATER 10.0)
       set(IOS_ARCH armv7k arm64_32)
     else()
       set(IOS_ARCH armv7k)
     endif()
   endif()
-elseif (IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
   set(XCODE_IOS_PLATFORM watchsimulator)
   if(NOT IOS_ARCH)
     set(IOS_ARCH x86_64)
@@ -194,130 +179,166 @@ else()
   message(FATAL_ERROR "Invalid IOS_PLATFORM: ${IOS_PLATFORM}")
 endif()
 message(STATUS "Configuring iOS build for platform: ${IOS_PLATFORM}, "
-  "architecture(s): ${IOS_ARCH}")
+               "architecture(s): ${IOS_ARCH}")
 # If user did not specify the SDK root to use, then query xcodebuild for it.
-execute_process(COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path
-    OUTPUT_VARIABLE CMAKE_OSX_SYSROOT_INT
-     OUTPUT_QUIET ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+execute_process(
+  COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path
+  OUTPUT_VARIABLE CMAKE_OSX_SYSROOT_INT
+  OUTPUT_QUIET ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 # If user did not specify the SDK root to use, then query xcodebuild for it.
-if (NOT DEFINED CMAKE_OSX_SYSROOT OR (NOT CMAKE_OSX_SYSROOT STREQUAL CMAKE_OSX_SYSROOT_INT))
-  execute_process(COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path
+if(NOT DEFINED CMAKE_OSX_SYSROOT OR (NOT CMAKE_OSX_SYSROOT STREQUAL
+                                     CMAKE_OSX_SYSROOT_INT))
+  execute_process(
+    COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path
     OUTPUT_VARIABLE CMAKE_OSX_SYSROOT
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 endif()
-if (NOT EXISTS ${CMAKE_OSX_SYSROOT})
-  message(SEND_ERROR "Please make sure that Xcode is installed and that the toolchain"
-  "is pointing to the correct path. Please run:"
-  "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"
-  "and see if that fixes the problem for you.")
+if(NOT EXISTS ${CMAKE_OSX_SYSROOT})
+  message(
+    SEND_ERROR "Please make sure that Xcode is installed and that the toolchain"
+               "is pointing to the correct path. Please run:"
+               "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"
+               "and see if that fixes the problem for you.")
   message(FATAL_ERROR "Invalid CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT} "
-  "does not exist.")
+                      "does not exist.")
 elseif(DEFINED CMAKE_OSX_SYSROOT)
-  message(STATUS "Using manually set SDK path: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}")
+  message(
+    STATUS
+      "Using manually set SDK path: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}")
 else()
-   message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}")
+  message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}")
 endif()
 # Specify minimum version of deployment target.
-if (NOT DEFINED IOS_DEPLOYMENT_TARGET)
-  if (IOS_PLATFORM STREQUAL "WATCHOS" OR IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
-    # Unless specified, SDK version 2.0 is used by default as minimum target version (watchOS).
-    set(IOS_DEPLOYMENT_TARGET "2.0"
-            CACHE STRING "Minimum iOS version to build for." )
+if(NOT DEFINED IOS_DEPLOYMENT_TARGET)
+  if(IOS_PLATFORM STREQUAL "WATCHOS" OR IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
+    # Unless specified, SDK version 2.0 is used by default as minimum target version
+    # (watchOS).
+    set(IOS_DEPLOYMENT_TARGET
+        "2.0"
+        CACHE STRING "Minimum iOS version to build for.")
   else()
-    # Unless specified, SDK version 10.0 is used by default as minimum target version (iOS, tvOS).
-    set(IOS_DEPLOYMENT_TARGET "10.0"
-            CACHE STRING "Minimum iOS version to build for." )
+    # Unless specified, SDK version 10.0 is used by default as minimum target version
+    # (iOS, tvOS).
+    set(IOS_DEPLOYMENT_TARGET
+        "10.0"
+        CACHE STRING "Minimum iOS version to build for.")
   endif()
-  message(STATUS "Using the default min-version since IOS_DEPLOYMENT_TARGET not provided!")
+  message(
+    STATUS "Using the default min-version since IOS_DEPLOYMENT_TARGET not provided!")
 endif()
 # Use bitcode or not
-if (NOT DEFINED ENABLE_BITCODE AND NOT IOS_ARCH MATCHES "((^|, )(i386|x86_64))+")
+if(NOT DEFINED ENABLE_BITCODE AND NOT IOS_ARCH MATCHES "((^|, )(i386|x86_64))+")
   # Unless specified, enable bitcode support by default
-  set(ENABLE_BITCODE TRUE CACHE BOOL "Whether or not to enable bitcode")
+  set(ENABLE_BITCODE
+      TRUE
+      CACHE BOOL "Whether or not to enable bitcode")
   message(STATUS "Enabling bitcode support by default. ENABLE_BITCODE not provided!")
 endif()
-if (NOT DEFINED ENABLE_BITCODE)
-  message(STATUS "Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!")
+if(NOT DEFINED ENABLE_BITCODE)
+  message(
+    STATUS
+      "Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!"
+  )
 endif()
 # Use ARC or not
-if (NOT DEFINED ENABLE_ARC)
+if(NOT DEFINED ENABLE_ARC)
   # Unless specified, enable ARC support by default
-  set(ENABLE_ARC TRUE CACHE BOOL "Whether or not to enable ARC")
+  set(ENABLE_ARC
+      TRUE
+      CACHE BOOL "Whether or not to enable ARC")
   message(STATUS "Enabling ARC support by default. ENABLE_ARC not provided!")
 endif()
 # Use hidden visibility or not
-if (NOT DEFINED ENABLE_VISIBILITY)
+if(NOT DEFINED ENABLE_VISIBILITY)
   # Unless specified, disable symbols visibility by default
-  set(ENABLE_VISIBILITY FALSE CACHE BOOL "Whether or not to hide symbols (-fvisibility=hidden)")
-  message(STATUS "Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!")
+  set(ENABLE_VISIBILITY
+      FALSE
+      CACHE BOOL "Whether or not to hide symbols (-fvisibility=hidden)")
+  message(
+    STATUS "Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!")
 endif()
 # Get the SDK version information.
-execute_process(COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
+execute_process(
+  COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
   OUTPUT_VARIABLE IOS_SDK_VERSION
-  ERROR_QUIET
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
-# Find the Developer root for the specific iOS platform being compiled for
-# from CMAKE_OSX_SYSROOT.  Should be ../../ from SDK specified in
-# CMAKE_OSX_SYSROOT.  There does not appear to be a direct way to obtain
-# this information from xcrun or xcodebuild.
-if (NOT CMAKE_IOS_DEVELOPER_ROOT)
+  ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+# Find the Developer root for the specific iOS platform being compiled for from
+# CMAKE_OSX_SYSROOT.  Should be ../../ from SDK specified in CMAKE_OSX_SYSROOT.  There
+# does not appear to be a direct way to obtain this information from xcrun or
+# xcodebuild.
+if(NOT CMAKE_IOS_DEVELOPER_ROOT)
   get_filename_component(IOS_PLATFORM_SDK_DIR ${CMAKE_OSX_SYSROOT} PATH)
   get_filename_component(CMAKE_IOS_DEVELOPER_ROOT ${IOS_PLATFORM_SDK_DIR} PATH)
 endif()
-if (NOT EXISTS ${CMAKE_IOS_DEVELOPER_ROOT})
+if(NOT EXISTS ${CMAKE_IOS_DEVELOPER_ROOT})
   message(FATAL_ERROR "Invalid CMAKE_IOS_DEVELOPER_ROOT: "
-    "${CMAKE_IOS_DEVELOPER_ROOT} does not exist.")
+                      "${CMAKE_IOS_DEVELOPER_ROOT} does not exist.")
 endif()
 # Find the C & C++ compilers for the specified SDK.
-if (NOT CMAKE_C_COMPILER)
-  execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang
+if(NOT CMAKE_C_COMPILER)
+  execute_process(
+    COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang
     OUTPUT_VARIABLE CMAKE_C_COMPILER
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
   message(STATUS "Using C compiler: ${CMAKE_C_COMPILER}")
 endif()
-if (NOT CMAKE_CXX_COMPILER)
-  execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++
+if(NOT CMAKE_CXX_COMPILER)
+  execute_process(
+    COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++
     OUTPUT_VARIABLE CMAKE_CXX_COMPILER
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
   message(STATUS "Using CXX compiler: ${CMAKE_CXX_COMPILER}")
 endif()
 # Find (Apple's) libtool.
-execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find libtool
+execute_process(
+  COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find libtool
   OUTPUT_VARIABLE IOS_LIBTOOL
-  ERROR_QUIET
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 message(STATUS "Using libtool: ${IOS_LIBTOOL}")
-# Configure libtool to be used instead of ar + ranlib to build static libraries.
-# This is required on Xcode 7+, but should also work on previous versions of
-# Xcode.
+# Configure libtool to be used instead of ar + ranlib to build static libraries. This is
+# required on Xcode 7+, but should also work on previous versions of Xcode.
 set(CMAKE_C_CREATE_STATIC_LIBRARY
-  "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
+    "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
 set(CMAKE_CXX_CREATE_STATIC_LIBRARY
-  "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
+    "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
 # Get the version of Darwin (OS X) of the host.
-execute_process(COMMAND uname -r
+execute_process(
+  COMMAND uname -r
   OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION
-  ERROR_QUIET
-  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
 # Standard settings.
-set(CMAKE_SYSTEM_NAME Darwin CACHE INTERNAL "")
-set(CMAKE_SYSTEM_VERSION ${IOS_SDK_VERSION} CACHE INTERNAL "")
-set(UNIX TRUE CACHE BOOL "")
-set(APPLE TRUE CACHE BOOL "")
-set(IOS TRUE CACHE BOOL "")
-set(CMAKE_AR ar CACHE FILEPATH "" FORCE)
-set(CMAKE_RANLIB ranlib CACHE FILEPATH "" FORCE)
-# Force unset of OS X-specific deployment target (otherwise autopopulated),
-# required as of cmake 2.8.10.
-set(CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING
-  "Must be empty for iOS builds." FORCE)
+set(CMAKE_SYSTEM_NAME
+    Darwin
+    CACHE INTERNAL "")
+set(CMAKE_SYSTEM_VERSION
+    ${IOS_SDK_VERSION}
+    CACHE INTERNAL "")
+set(UNIX
+    TRUE
+    CACHE BOOL "")
+set(APPLE
+    TRUE
+    CACHE BOOL "")
+set(IOS
+    TRUE
+    CACHE BOOL "")
+set(CMAKE_AR
+    ar
+    CACHE FILEPATH "" FORCE)
+set(CMAKE_RANLIB
+    ranlib
+    CACHE FILEPATH "" FORCE)
+# Force unset of OS X-specific deployment target (otherwise autopopulated), required as
+# of cmake 2.8.10.
+set(CMAKE_OSX_DEPLOYMENT_TARGET
+    ""
+    CACHE STRING "Must be empty for iOS builds." FORCE)
 # Set the architectures for which to build.
-set(CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE STRING "Build architecture for iOS")
-# Change the type of target generated for try_compile() so it'll work when cross-compiling
+set(CMAKE_OSX_ARCHITECTURES
+    ${IOS_ARCH}
+    CACHE STRING "Build architecture for iOS")
+# Change the type of target generated for try_compile() so it'll work when
+# cross-compiling
 set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 # All iOS/Darwin specific settings - some may be redundant.
 set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
@@ -332,7 +353,8 @@ set(CMAKE_MODULE_EXISTS 1)
 set(CMAKE_DL_LIBS "")
 set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
 set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
-set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
+set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG
+    "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
 set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
 
 if(IOS_ARCH MATCHES "((^|, )(arm64|arm64e|x86_64))+")
@@ -350,35 +372,32 @@ message(STATUS "Building for minimum iOS version: ${IOS_DEPLOYMENT_TARGET}"
 # Note that only Xcode 7+ supports the newer more specific:
 # -m${XCODE_IOS_PLATFORM}-version-min flags, older versions of Xcode use:
 # -m(ios/ios-simulator)-version-min instead.
-if (IOS_PLATFORM STREQUAL "OS" OR IOS_PLATFORM STREQUAL "OS64")
-  if (XCODE_VERSION VERSION_LESS 7.0)
-    set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-      "-mios-version-min=${IOS_DEPLOYMENT_TARGET}")
+if(IOS_PLATFORM STREQUAL "OS" OR IOS_PLATFORM STREQUAL "OS64")
+  if(XCODE_VERSION VERSION_LESS 7.0)
+    set(XCODE_IOS_PLATFORM_VERSION_FLAGS "-mios-version-min=${IOS_DEPLOYMENT_TARGET}")
   else()
     # Xcode 7.0+ uses flags we can build directly from XCODE_IOS_PLATFORM.
     set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-      "-m${XCODE_IOS_PLATFORM}-version-min=${IOS_DEPLOYMENT_TARGET}")
+        "-m${XCODE_IOS_PLATFORM}-version-min=${IOS_DEPLOYMENT_TARGET}")
   endif()
-elseif (IOS_PLATFORM STREQUAL "TVOS")
-  set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-    "-mtvos-version-min=${IOS_DEPLOYMENT_TARGET}")
-elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
-  set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-    "-mtvos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
-elseif (IOS_PLATFORM STREQUAL "WATCHOS")
+elseif(IOS_PLATFORM STREQUAL "TVOS")
+  set(XCODE_IOS_PLATFORM_VERSION_FLAGS "-mtvos-version-min=${IOS_DEPLOYMENT_TARGET}")
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
   set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-    "-mwatchos-version-min=${IOS_DEPLOYMENT_TARGET}")
-elseif (IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
+      "-mtvos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
+elseif(IOS_PLATFORM STREQUAL "WATCHOS")
+  set(XCODE_IOS_PLATFORM_VERSION_FLAGS "-mwatchos-version-min=${IOS_DEPLOYMENT_TARGET}")
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR_WATCHOS")
   set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-    "-mwatchos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
+      "-mwatchos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
 else()
   # SIMULATOR or SIMULATOR64 both use -mios-simulator-version-min.
   set(XCODE_IOS_PLATFORM_VERSION_FLAGS
-    "-mios-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
+      "-mios-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
 endif()
 message(STATUS "Version flags set to: ${XCODE_IOS_PLATFORM_VERSION_FLAGS}")
 
-if (ENABLE_BITCODE)
+if(ENABLE_BITCODE)
   set(BITCODE "-fembed-bitcode")
   set(HEADER_PAD "")
   message(STATUS "Enabling bitcode support.")
@@ -388,7 +407,7 @@ else()
   message(STATUS "Disabling bitcode support.")
 endif()
 
-if (ENABLE_ARC)
+if(ENABLE_ARC)
   set(FOBJC_ARC "-fobjc-arc")
   message(STATUS "Enabling ARC support.")
 else()
@@ -396,7 +415,7 @@ else()
   message(STATUS "Disabling ARC support.")
 endif()
 
-if (NOT ENABLE_VISIBILITY)
+if(NOT ENABLE_VISIBILITY)
   set(VISIBILITY "-fvisibility=hidden")
   message(STATUS "Hiding symbols (-fvisibility=hidden).")
 else()
@@ -404,20 +423,31 @@ else()
 endif()
 
 set(CMAKE_C_FLAGS
-"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_C_FLAGS}")
+    "${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_C_FLAGS}"
+)
 # Hidden visibilty is required for C++ on iOS.
 set(CMAKE_CXX_FLAGS
-"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fvisibility-inlines-hidden -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_CXX_FLAGS}")
-set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_MINSIZEREL}")
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELEASE}")
-set(CMAKE_C_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
-set(CMAKE_CXX_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS}  -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
+    "${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fvisibility-inlines-hidden -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_CXX_FLAGS}"
+)
+set(CMAKE_CXX_FLAGS_MINSIZEREL
+    "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_MINSIZEREL}"
+)
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO
+    "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}"
+)
+set(CMAKE_CXX_FLAGS_RELEASE
+    "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELEASE}")
+set(CMAKE_C_LINK_FLAGS
+    "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
+set(CMAKE_CXX_LINK_FLAGS
+    "${XCODE_IOS_PLATFORM_VERSION_FLAGS}  -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}"
+)
 
-# In order to ensure that the updated compiler flags are used in try_compile()
-# tests, we have to forcibly set them in the CMake cache, not merely set them
-# in the local scope.
-list(APPEND VARS_TO_FORCE_IN_CACHE
+# In order to ensure that the updated compiler flags are used in try_compile() tests, we
+# have to forcibly set them in the CMake cache, not merely set them in the local scope.
+list(
+  APPEND
+  VARS_TO_FORCE_IN_CACHE
   CMAKE_C_FLAGS
   CMAKE_CXX_FLAGS
   CMAKE_CXX_FLAGS_RELWITHDEBINFO
@@ -426,37 +456,40 @@ list(APPEND VARS_TO_FORCE_IN_CACHE
   CMAKE_C_LINK_FLAGS
   CMAKE_CXX_LINK_FLAGS)
 foreach(VAR_TO_FORCE ${VARS_TO_FORCE_IN_CACHE})
-  set(${VAR_TO_FORCE} "${${VAR_TO_FORCE}}" CACHE STRING "")
+  set(${VAR_TO_FORCE}
+      "${${VAR_TO_FORCE}}"
+      CACHE STRING "")
 endforeach()
 
 set(CMAKE_PLATFORM_HAS_INSTALLNAME 1)
-set (CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks")
+set(CMAKE_SHARED_LINKER_FLAGS
+    "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks")
 set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib ${HEADER_PAD}")
 set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle ${HEADER_PAD}")
 set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
 set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
 set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
 
-# Hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old
-# build tree (where install_name_tool was hardcoded) and where
-# CMAKE_INSTALL_NAME_TOOL isn't in the cache and still cmake didn't fail in
-# CMakeFindBinUtils.cmake (because it isn't rerun) hardcode
-# CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did
+# Hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old build tree
+# (where install_name_tool was hardcoded) and where CMAKE_INSTALL_NAME_TOOL isn't in the
+# cache and still cmake didn't fail in CMakeFindBinUtils.cmake (because it isn't rerun)
+# hardcode CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did
 # before, Alex.
-if (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+if(NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
   find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool)
-endif (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+endif(NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
 
 # Set the find root to the iOS developer roots and to user defined paths.
-set(CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_OSX_SYSROOT}
-  ${CMAKE_PREFIX_PATH} CACHE STRING  "iOS find search path root" FORCE)
+set(CMAKE_FIND_ROOT_PATH
+    ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_OSX_SYSROOT} ${CMAKE_PREFIX_PATH}
+    CACHE STRING "iOS find search path root" FORCE)
 # Default to searching for frameworks first.
 set(CMAKE_FIND_FRAMEWORK FIRST)
 # Set up the default search directories for frameworks.
 set(CMAKE_SYSTEM_FRAMEWORK_PATH
-  ${CMAKE_OSX_SYSROOT}/System/Library/Frameworks
-  ${CMAKE_OSX_SYSROOT}/System/Library/PrivateFrameworks
-  ${CMAKE_OSX_SYSROOT}/Developer/Library/Frameworks)
+    ${CMAKE_OSX_SYSROOT}/System/Library/Frameworks
+    ${CMAKE_OSX_SYSROOT}/System/Library/PrivateFrameworks
+    ${CMAKE_OSX_SYSROOT}/Developer/Library/Frameworks)
 # Only search the specified iOS SDK, not the remainder of the host filesystem.
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
@@ -464,12 +497,14 @@ set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 # This little macro lets you set any XCode specific property.
 macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE XCODE_RELVERSION)
   set(XCODE_RELVERSION_I "${XCODE_RELVERSION}")
-  if (XCODE_RELVERSION_I STREQUAL "All")
-    set_property(TARGET ${TARGET} PROPERTY
-    XCODE_ATTRIBUTE_${XCODE_PROPERTY} "${XCODE_VALUE}")
+  if(XCODE_RELVERSION_I STREQUAL "All")
+    set_property(TARGET ${TARGET} PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY}
+                                           "${XCODE_VALUE}")
   else()
-    set_property(TARGET ${TARGET} PROPERTY
-    XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}] "${XCODE_VALUE}")
+    set_property(
+      TARGET ${TARGET}
+      PROPERTY XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}]
+               "${XCODE_VALUE}")
   endif()
 endmacro(set_xcode_property)
 # This macro lets you find executable programs on the host system.

toolchains/riscv64-linux-gnu.toolchain.cmake

@@ -3,16 +3,18 @@ set(CMAKE_SYSTEM_PROCESSOR riscv64)
 set(RISCV_CROSS_BUILD_ARCH riscv64)
 
 if(DEFINED ENV{RISCV_TOOLCHAIN_ROOT})
-    file(TO_CMAKE_PATH $ENV{RISCV_TOOLCHAIN_ROOT} RISCV_TOOLCHAIN_ROOT)
+  file(TO_CMAKE_PATH $ENV{RISCV_TOOLCHAIN_ROOT} RISCV_TOOLCHAIN_ROOT)
 else()
-    message(FATAL_ERROR "RISCV_TOOLCHAIN_ROOT env must be defined")
+  message(FATAL_ERROR "RISCV_TOOLCHAIN_ROOT env must be defined")
 endif()
 
-set(RISCV_TOOLCHAIN_ROOT ${RISCV_TOOLCHAIN_ROOT} CACHE STRING "root path to riscv toolchain")
+set(RISCV_TOOLCHAIN_ROOT
+    ${RISCV_TOOLCHAIN_ROOT}
+    CACHE STRING "root path to riscv toolchain")
 
 set(CMAKE_C_COMPILER "${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-gcc")
 set(CMAKE_CXX_COMPILER "${RISCV_TOOLCHAIN_ROOT}/bin/riscv64-unknown-linux-gnu-g++")
 set(CMAKE_FIND_ROOT_PATH "${RISCV_TOOLCHAIN_ROOT}/riscv64-unknown-linux-gnu")
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

tools/mlir/mgb-file-check/CMakeLists.txt

@@ -1,8 +1,8 @@
 add_custom_command(
-    OUTPUT link_sh
-    COMMAND ${CMAKE_COMMAND} -E create_symlink
-        ${PROJECT_SOURCE_DIR}/tools/mlir/mgb-file-check/mgb-file-check.sh
-        ${PROJECT_BINARY_DIR}/tools/mlir/mgb-file-check/mgb-file-check
-)
+  OUTPUT link_sh
+  COMMAND
+    ${CMAKE_COMMAND} -E create_symlink
+    ${PROJECT_SOURCE_DIR}/tools/mlir/mgb-file-check/mgb-file-check.sh
+    ${PROJECT_BINARY_DIR}/tools/mlir/mgb-file-check/mgb-file-check)
 
-add_custom_target(mgb-file-check DEPENDS link_sh)
+add_custom_target(mgb-file-check DEPENDS link_sh)

tools/mlir/mgb-opt/CMakeLists.txt

@@ -1,20 +1,18 @@
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(conversion_libs GLOBAL PROPERTY MLIR_CONVERSION_LIBS)
 set(LIBS
-        ${dialect_libs}
-        ${conversion_libs}
-        LLVMSupport
-        MLIROptLib
-        MLIRIR
-        MLIRPass
-        MLIRSupport
-        )
+    ${dialect_libs}
+    ${conversion_libs}
+    LLVMSupport
+    MLIROptLib
+    MLIRIR
+    MLIRPass
+    MLIRSupport)
 add_executable(mgb-opt mgb-opt.cpp)
 
 target_include_directories(
-  mgb-opt
-  PRIVATE ${MLIR_LLVM_INCLUDE_DIR} ${PROJECT_SOURCE_DIR}/src/jit/include
-          ${PROJECT_BINARY_DIR}/src/jit/include)
+  mgb-opt PRIVATE ${MLIR_LLVM_INCLUDE_DIR} ${PROJECT_SOURCE_DIR}/src/jit/include
+                  ${PROJECT_BINARY_DIR}/src/jit/include)
 
 add_dependencies(mgb-opt mgb_dialect)