Merge pull request #192 from youny626/cpu_version

Pure CPU version for Milvus

CHANGELOG.md

@@ -7,6 +7,7 @@ Please mark all change in change log and use the ticket from JIRA.
 ## Bug
 
 ## Feature
+- \#12 - Pure CPU version for Milvus
 
 ## Improvement
 

core/CMakeLists.txt

@@ -23,9 +23,9 @@ message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-MACRO (GET_CURRENT_TIME CURRENT_TIME)
+MACRO(GET_CURRENT_TIME CURRENT_TIME)
     execute_process(COMMAND "date" +"%Y-%m-%d %H:%M.%S" OUTPUT_VARIABLE ${CURRENT_TIME})
-ENDMACRO (GET_CURRENT_TIME)
+ENDMACRO(GET_CURRENT_TIME)
 
 GET_CURRENT_TIME(BUILD_TIME)
 string(REGEX REPLACE "\n" "" BUILD_TIME ${BUILD_TIME})
@@ -42,23 +42,20 @@ GET_GIT_BRANCH_NAME(GIT_BRANCH_NAME)
 message(STATUS "GIT_BRANCH_NAME = ${GIT_BRANCH_NAME}")
 if(NOT GIT_BRANCH_NAME STREQUAL "")
     string(REGEX REPLACE "\n" "" GIT_BRANCH_NAME ${GIT_BRANCH_NAME})
-endif()
+endif ()
 
-set(MILVUS_VERSION "0.5.1")
+set(MILVUS_VERSION "${GIT_BRANCH_NAME}")
 string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]" MILVUS_VERSION "${MILVUS_VERSION}")
 
-find_package(ClangTools)
-set(BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build-support")
-
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
     set(BUILD_TYPE "Release")
-else()
+else ()
     set(BUILD_TYPE "Debug")
-endif()
+endif ()
 message(STATUS "Build type = ${BUILD_TYPE}")
 
 project(milvus VERSION "${MILVUS_VERSION}")
-project(milvus_engine LANGUAGES CUDA CXX)
+project(milvus_engine LANGUAGES CXX)
 
 unset(CMAKE_EXPORT_COMPILE_COMMANDS CACHE)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
@@ -67,15 +64,15 @@ set(MILVUS_VERSION_MAJOR "${milvus_VERSION_MAJOR}")
 set(MILVUS_VERSION_MINOR "${milvus_VERSION_MINOR}")
 set(MILVUS_VERSION_PATCH "${milvus_VERSION_PATCH}")
 
-if(MILVUS_VERSION_MAJOR STREQUAL ""
+if (MILVUS_VERSION_MAJOR STREQUAL ""
         OR MILVUS_VERSION_MINOR STREQUAL ""
         OR MILVUS_VERSION_PATCH STREQUAL "")
     message(WARNING "Failed to determine Milvus version from git branch name")
     set(MILVUS_VERSION "0.5.0")
-endif()
+endif ()
 
 message(STATUS "Build version = ${MILVUS_VERSION}")
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/version.h.macro ${CMAKE_CURRENT_SOURCE_DIR}/src/version.h)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/src/config.h @ONLY)
 
 message(STATUS "Milvus version: "
         "${MILVUS_VERSION_MAJOR}.${MILVUS_VERSION_MINOR}.${MILVUS_VERSION_PATCH} "
@@ -84,46 +81,33 @@ message(STATUS "Milvus version: "
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED on)
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
     message(STATUS "Building milvus_engine on x86 architecture")
     set(MILVUS_BUILD_ARCH x86_64)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
     message(STATUS "Building milvus_engine on ppc architecture")
     set(MILVUS_BUILD_ARCH ppc64le)
-else()
+else ()
     message(WARNING "Unknown processor type")
     message(WARNING "CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
     set(MILVUS_BUILD_ARCH unknown)
-endif()
-
-find_package (Python COMPONENTS Interpreter Development)
-
-find_package(CUDA)
-set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler -fPIC -std=c++11 -D_FORCE_INLINES --expt-extended-lambda")
-
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
-else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
-endif()
+endif ()
 
 # Ensure that a default make is set
-if("${MAKE}" STREQUAL "")
-    if(NOT MSVC)
+if ("${MAKE}" STREQUAL "")
+    if (NOT MSVC)
         find_program(MAKE make)
-    endif()
-endif()
+    endif ()
+endif ()
 
 find_path(MYSQL_INCLUDE_DIR
-            NAMES "mysql.h"
-            PATH_SUFFIXES "mysql")
+        NAMES "mysql.h"
+        PATH_SUFFIXES "mysql")
 if (${MYSQL_INCLUDE_DIR} STREQUAL "MYSQL_INCLUDE_DIR-NOTFOUND")
     message(FATAL_ERROR "Could not found MySQL include directory")
-else()
+else ()
     include_directories(${MYSQL_INCLUDE_DIR})
-endif()
+endif ()
 
 set(MILVUS_SOURCE_DIR ${PROJECT_SOURCE_DIR})
 set(MILVUS_BINARY_DIR ${PROJECT_BINARY_DIR})
@@ -134,26 +118,50 @@ include(DefineOptions)
 include(BuildUtils)
 include(ThirdPartyPackages)
 
-config_summary()
+set(MILVUS_GPU_VERSION false)
+if (MILVUS_CPU_VERSION)
+    message(STATUS "Building Milvus CPU version")
+    add_compile_definitions("MILVUS_CPU_VERSION")
+else ()
+    message(STATUS "Building Milvus GPU version")
+    set(MILVUS_GPU_VERSION true)
+    add_compile_definitions("MILVUS_GPU_VERSION")
+    enable_language(CUDA)
+    find_package(CUDA 10 REQUIRED)
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler -fPIC -std=c++11 -D_FORCE_INLINES --expt-extended-lambda")
+endif ()
+
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    if (MILVUS_GPU_VERSION)
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
+    endif ()
+else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    if (MILVUS_GPU_VERSION)
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
+    endif ()
+endif ()
 
 if (CUSTOMIZATION)
     add_definitions(-DCUSTOMIZATION)
 endif (CUSTOMIZATION)
 
+config_summary()
 add_subdirectory(src)
 
 if (BUILD_UNIT_TEST STREQUAL "ON")
     if (BUILD_COVERAGE STREQUAL "ON")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-    endif()
+    endif ()
     add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/unittest)
-endif()
+endif ()
 
 add_custom_target(Clean-All COMMAND ${CMAKE_BUILD_TOOL} clean)
 
-if("${MILVUS_DB_PATH}" STREQUAL "")
+if ("${MILVUS_DB_PATH}" STREQUAL "")
     set(MILVUS_DB_PATH "/tmp/milvus")
-endif()
+endif ()
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.yaml)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.conf)
 
@@ -169,19 +177,22 @@ install(FILES
         DESTINATION
         conf)
 
+find_package(Python COMPONENTS Interpreter Development)
+find_package(ClangTools)
+set(BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build-support")
 
 #
 # "make lint" target
 #
-if(NOT MILVUS_VERBOSE_LINT)
-  set(MILVUS_LINT_QUIET "--quiet")
-endif()
+if (NOT MILVUS_VERBOSE_LINT)
+    set(MILVUS_LINT_QUIET "--quiet")
+endif ()
 
-if(NOT LINT_EXCLUSIONS_FILE)
-  # source files matching a glob from a line in this file
-  # will be excluded from linting (cpplint, clang-tidy, clang-format)
-  set(LINT_EXCLUSIONS_FILE ${BUILD_SUPPORT_DIR}/lint_exclusions.txt)
-endif()
+if (NOT LINT_EXCLUSIONS_FILE)
+    # source files matching a glob from a line in this file
+    # will be excluded from linting (cpplint, clang-tidy, clang-format)
+    set(LINT_EXCLUSIONS_FILE ${BUILD_SUPPORT_DIR}/lint_exclusions.txt)
+endif ()
 
 find_program(CPPLINT_BIN NAMES cpplint cpplint.py HINTS ${BUILD_SUPPORT_DIR})
 message(STATUS "Found cpplint executable at ${CPPLINT_BIN}")
@@ -190,77 +201,76 @@ message(STATUS "Found cpplint executable at ${CPPLINT_BIN}")
 # "make lint" targets
 #
 add_custom_target(lint
-                  ${PYTHON_EXECUTABLE}
-                  ${BUILD_SUPPORT_DIR}/run_cpplint.py
-                  --cpplint_binary
-                  ${CPPLINT_BIN}
-                  --exclude_globs
-                  ${LINT_EXCLUSIONS_FILE}
-                  --source_dir
-                  ${CMAKE_CURRENT_SOURCE_DIR}
-                  ${MILVUS_LINT_QUIET})
+        ${PYTHON_EXECUTABLE}
+        ${BUILD_SUPPORT_DIR}/run_cpplint.py
+        --cpplint_binary
+        ${CPPLINT_BIN}
+        --exclude_globs
+        ${LINT_EXCLUSIONS_FILE}
+        --source_dir
+        ${CMAKE_CURRENT_SOURCE_DIR}
+        ${MILVUS_LINT_QUIET})
 
 #
 # "make clang-format" and "make check-clang-format" targets
 #
-if(${CLANG_FORMAT_FOUND})
-  # runs clang format and updates files in place.
-  add_custom_target(clang-format
-                    ${PYTHON_EXECUTABLE}
-                    ${BUILD_SUPPORT_DIR}/run_clang_format.py
-                    --clang_format_binary
-                    ${CLANG_FORMAT_BIN}
-                    --exclude_globs
-                    ${LINT_EXCLUSIONS_FILE}
-                    --source_dir
-                    ${CMAKE_CURRENT_SOURCE_DIR}/src
-                    --fix
-                    ${MILVUS_LINT_QUIET})
-
-  # runs clang format and exits with a non-zero exit code if any files need to be reformatted
-  add_custom_target(check-clang-format
-                    ${PYTHON_EXECUTABLE}
-                    ${BUILD_SUPPORT_DIR}/run_clang_format.py
-                    --clang_format_binary
-                    ${CLANG_FORMAT_BIN}
-                    --exclude_globs
-                    ${LINT_EXCLUSIONS_FILE}
-                    --source_dir
-                    ${CMAKE_CURRENT_SOURCE_DIR}/src
-                    ${MILVUS_LINT_QUIET})
-endif()
+if (${CLANG_FORMAT_FOUND})
+    # runs clang format and updates files in place.
+    add_custom_target(clang-format
+            ${PYTHON_EXECUTABLE}
+            ${BUILD_SUPPORT_DIR}/run_clang_format.py
+            --clang_format_binary
+            ${CLANG_FORMAT_BIN}
+            --exclude_globs
+            ${LINT_EXCLUSIONS_FILE}
+            --source_dir
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            --fix
+            ${MILVUS_LINT_QUIET})
+
+    # runs clang format and exits with a non-zero exit code if any files need to be reformatted
+    add_custom_target(check-clang-format
+            ${PYTHON_EXECUTABLE}
+            ${BUILD_SUPPORT_DIR}/run_clang_format.py
+            --clang_format_binary
+            ${CLANG_FORMAT_BIN}
+            --exclude_globs
+            ${LINT_EXCLUSIONS_FILE}
+            --source_dir
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${MILVUS_LINT_QUIET})
+endif ()
 
 #
 # "make clang-tidy" and "make check-clang-tidy" targets
 #
-if(${CLANG_TIDY_FOUND})
-  # runs clang-tidy and attempts to fix any warning automatically
-  add_custom_target(clang-tidy
-                    ${PYTHON_EXECUTABLE}
-                    ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
-                    --clang_tidy_binary
-                    ${CLANG_TIDY_BIN}
-                    --exclude_globs
-                    ${LINT_EXCLUSIONS_FILE}
-                    --compile_commands
-                    ${CMAKE_BINARY_DIR}/compile_commands.json
-                    --source_dir
-                    ${CMAKE_CURRENT_SOURCE_DIR}/src
-                    --fix
-                    ${MILVUS_LINT_QUIET})
-
-  # runs clang-tidy and exits with a non-zero exit code if any errors are found.
-  add_custom_target(check-clang-tidy
-                    ${PYTHON_EXECUTABLE}
-                    ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
-                    --clang_tidy_binary
-                    ${CLANG_TIDY_BIN}
-                    --exclude_globs
-                    ${LINT_EXCLUSIONS_FILE}
-                    --compile_commands
-                    ${CMAKE_BINARY_DIR}/compile_commands.json
-                    --source_dir
-                    ${CMAKE_CURRENT_SOURCE_DIR}/src
-                    ${MILVUS_LINT_QUIET})
-endif()
-
+if (${CLANG_TIDY_FOUND})
+    # runs clang-tidy and attempts to fix any warning automatically
+    add_custom_target(clang-tidy
+            ${PYTHON_EXECUTABLE}
+            ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
+            --clang_tidy_binary
+            ${CLANG_TIDY_BIN}
+            --exclude_globs
+            ${LINT_EXCLUSIONS_FILE}
+            --compile_commands
+            ${CMAKE_BINARY_DIR}/compile_commands.json
+            --source_dir
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            --fix
+            ${MILVUS_LINT_QUIET})
+
+    # runs clang-tidy and exits with a non-zero exit code if any errors are found.
+    add_custom_target(check-clang-tidy
+            ${PYTHON_EXECUTABLE}
+            ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
+            --clang_tidy_binary
+            ${CLANG_TIDY_BIN}
+            --exclude_globs
+            ${LINT_EXCLUSIONS_FILE}
+            --compile_commands
+            ${CMAKE_BINARY_DIR}/compile_commands.json
+            --source_dir
+            ${CMAKE_CURRENT_SOURCE_DIR}/src
+            ${MILVUS_LINT_QUIET})
+endif ()
\ No newline at end of file

core/build.sh

@@ -12,6 +12,8 @@ USE_JFROG_CACHE="OFF"
 RUN_CPPLINT="OFF"
 CUSTOMIZATION="OFF" # default use ori faiss
 CUDA_COMPILER=/usr/local/cuda/bin/nvcc
+CPU_VERSION="OFF"
+WITH_MKL="OFF"
 
 CUSTOMIZED_FAISS_URL="${FAISS_URL:-NONE}"
 wget -q --method HEAD ${CUSTOMIZED_FAISS_URL}
@@ -21,7 +23,7 @@ else
   CUSTOMIZATION="OFF"
 fi
 
-while getopts "p:d:t:ulrcgjhx" arg
+while getopts "p:d:t:ulrcgjhxzm" arg
 do
         case $arg in
              p)
@@ -58,6 +60,12 @@ do
              x)
                 CUSTOMIZATION="OFF" # force use ori faiss
                 ;;
+             z)
+                CPU_VERSION="ON"
+                ;;
+             m)
+                WITH_MKL="ON"
+                ;;   
              h) # help
                 echo "
 
@@ -71,10 +79,12 @@ parameter:
 -c: code coverage(default: OFF)
 -g: profiling(default: OFF)
 -j: use jfrog cache build directory(default: OFF)
+-z: build pure CPU version(default: OFF)
+-m: build with MKL(default: OFF)
 -h: help
 
 usage:
-./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-h]
+./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-z] [-m] [-h]
                 "
                 exit 0
                 ;;
@@ -106,6 +116,8 @@ CMAKE_CMD="cmake \
 -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
 -DCUSTOMIZATION=${CUSTOMIZATION} \
 -DFAISS_URL=${CUSTOMIZED_FAISS_URL} \
+-DMILVUS_CPU_VERSION=${CPU_VERSION} \
+-DBUILD_FAISS_WITH_MKL=${WITH_MKL} \
 ../"
 echo ${CMAKE_CMD}
 ${CMAKE_CMD}
@@ -147,4 +159,4 @@ else
 
     # compile and build
     make -j 8 install || exit 1
-fi
\ No newline at end of file
+fi

core/cmake/DefineOptions.cmake

@@ -40,6 +40,11 @@ macro(define_option_string name description default)
     endif()
 endmacro()
 
+#----------------------------------------------------------------------
+set_option_category("CPU version")
+
+define_option(MILVUS_CPU_VERSION "Build CPU version only" OFF)
+
 #----------------------------------------------------------------------
 set_option_category("Thirdparty")
 

core/conf/server_config.template

@@ -27,11 +27,14 @@ metric_config:
     port: 8080                      # port prometheus uses to fetch metrics, must in range [1025, 65534]
 
 cache_config:
+
   cpu_cache_capacity: 16            # GB, CPU memory used for cache, must be a positive integer
   cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
+  cache_insert_data: false          # whether to load inserted data into cache, must be a boolean
+
+# Skip the following config if you are using GPU version
   gpu_cache_capacity: 4             # GB, GPU memory used for cache, must be a positive integer
   gpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered, must be in range (0.0, 1.0]
-  cache_insert_data: false          # whether to load inserted data into cache, must be a boolean
 
 engine_config:
   use_blas_threshold: 20            # if nq <  use_blas_threshold, use SSE, faster with fluctuated response times
@@ -39,6 +42,7 @@ engine_config:
   gpu_search_threshold: 1000        # threshold beyond which the search computation is executed on GPUs only
 
 resource_config:
-  search_resources:                 # define the GPUs used for search computation, must be in format: gpux
+  search_resources:                 # define the CPU / GPUs used for search computation, must be in format: cpu / gpux
+    - cpu
     - gpu0
-  index_build_device: gpu0          # GPU used for building index, must be in format: gpux
\ No newline at end of file
+  index_build_device: gpu0           # CPU / GPU used for building index, must be in format: cpu / gpux

core/src/CMakeLists.txt

@@ -20,11 +20,9 @@
 include_directories(${MILVUS_SOURCE_DIR})
 include_directories(${MILVUS_ENGINE_SRC})
 
-include_directories(${CUDA_TOOLKIT_ROOT_DIR}/include)
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-status)
 include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-milvus)
 
-#this statement must put here, since the INDEX_INCLUDE_DIRS is defined in code/CMakeList.txt
 add_subdirectory(index)
 
 set(INDEX_INCLUDE_DIRS ${INDEX_INCLUDE_DIRS} PARENT_SCOPE)
@@ -109,35 +107,45 @@ set(boost_lib
         libboost_serialization.a
         )
 
-set(cuda_lib
-        ${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/libnvidia-ml.so
-        cudart
-        cublas
-        )
-
 set(third_party_libs
         sqlite
         ${client_grpc_lib}
         yaml-cpp
         ${prometheus_lib}
-        ${cuda_lib}
         mysqlpp
         zlib
         ${boost_lib}
         )
 
+if (MILVUS_GPU_VERSION)
+    include_directories(${CUDA_INCLUDE_DIRS})
+    link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+    set(cuda_lib
+            ${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/libnvidia-ml.so
+            cudart
+            cublas
+            )
+    set(third_party_libs ${third_party_libs}
+            ${cuda_lib}
+            )
+    aux_source_directory(${MILVUS_ENGINE_SRC}/wrapper/gpu wrapper_gpu_files)
+    set(engine_files ${engine_files}
+            ${wrapper_gpu_files}
+            )
+endif ()
+
 if (MILVUS_ENABLE_PROFILING STREQUAL "ON")
     set(third_party_libs ${third_party_libs}
-        gperftools
-        libunwind
-        )
+            gperftools
+            libunwind
+            )
 endif ()
 
-link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
 set(engine_libs
         pthread
         libgomp.a
         libgfortran.a
+        dl
         )
 
 if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
@@ -147,11 +155,11 @@ if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
             )
 endif ()
 
-cuda_add_library(milvus_engine STATIC ${engine_files})
+add_library(milvus_engine STATIC ${engine_files})
 target_link_libraries(milvus_engine
         knowhere
-        ${engine_libs}
         ${third_party_libs}
+        ${engine_libs}
         )
 
 add_library(metrics STATIC ${metrics_files})
@@ -165,8 +173,6 @@ target_link_libraries(metrics ${metrics_lib})
 
 set(server_libs
         milvus_engine
-        pthread
-        dl
         metrics
         )
 

core/src/cache/Cache.inl

@@ -15,24 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-
-
-
 namespace milvus {
 namespace cache {
 
 constexpr double DEFAULT_THRESHHOLD_PERCENT = 0.85;
 
-template<typename ItemObj>
+template <typename ItemObj>
 Cache<ItemObj>::Cache(int64_t capacity, uint64_t cache_max_count)
-    : usage_(0),
-      capacity_(capacity),
-      freemem_percent_(DEFAULT_THRESHHOLD_PERCENT),
-      lru_(cache_max_count) {
-//    AGENT_LOG_DEBUG << "Construct Cache with capacity " << std::to_string(mem_capacity)
+    : usage_(0), capacity_(capacity), freemem_percent_(DEFAULT_THRESHHOLD_PERCENT), lru_(cache_max_count) {
+    //    AGENT_LOG_DEBUG << "Construct Cache with capacity " << std::to_string(mem_capacity)
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 Cache<ItemObj>::set_capacity(int64_t capacity) {
     if (capacity > 0) {
@@ -41,23 +35,23 @@ Cache<ItemObj>::set_capacity(int64_t capacity) {
     }
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 size_t
 Cache<ItemObj>::size() const {
     std::lock_guard<std::mutex> lock(mutex_);
     return lru_.size();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 bool
-Cache<ItemObj>::exists(const std::string &key) {
+Cache<ItemObj>::exists(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
     return lru_.exists(key);
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 ItemObj
-Cache<ItemObj>::get(const std::string &key) {
+Cache<ItemObj>::get(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!lru_.exists(key)) {
         return nullptr;
@@ -66,60 +60,59 @@ Cache<ItemObj>::get(const std::string &key) {
     return lru_.get(key);
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
-Cache<ItemObj>::insert(const std::string &key, const ItemObj &item) {
+Cache<ItemObj>::insert(const std::string& key, const ItemObj& item) {
     if (item == nullptr) {
         return;
     }
 
-//    if(item->size() > capacity_) {
-//        SERVER_LOG_ERROR << "Item size " << item->size()
-//                        << " is too large to insert into cache, capacity " << capacity_;
-//        return;
-//    }
+    //    if(item->size() > capacity_) {
+    //        SERVER_LOG_ERROR << "Item size " << item->size()
+    //                        << " is too large to insert into cache, capacity " << capacity_;
+    //        return;
+    //    }
 
-    //calculate usage
+    // calculate usage
     {
         std::lock_guard<std::mutex> lock(mutex_);
 
-        //if key already exist, subtract old item size
+        // if key already exist, subtract old item size
         if (lru_.exists(key)) {
-            const ItemObj &old_item = lru_.get(key);
+            const ItemObj& old_item = lru_.get(key);
             usage_ -= old_item->Size();
         }
 
-        //plus new item size
+        // plus new item size
         usage_ += item->Size();
     }
 
-    //if usage exceed capacity, free some items
+    // if usage exceed capacity, free some items
     if (usage_ > capacity_) {
-        SERVER_LOG_DEBUG << "Current usage " << usage_
-                         << " exceeds cache capacity " << capacity_
+        SERVER_LOG_DEBUG << "Current usage " << usage_ << " exceeds cache capacity " << capacity_
                          << ", start free memory";
         free_memory();
     }
 
-    //insert new item
+    // insert new item
     {
         std::lock_guard<std::mutex> lock(mutex_);
 
         lru_.put(key, item);
-        SERVER_LOG_DEBUG << "Insert " << key << " size:" << item->Size()
-                         << " bytes into cache, usage: " << usage_ << " bytes";
+        SERVER_LOG_DEBUG << "Insert " << key << " size:" << item->Size() << " bytes into cache, usage: " << usage_
+                         << " bytes";
     }
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
-Cache<ItemObj>::erase(const std::string &key) {
+Cache<ItemObj>::erase(const std::string& key) {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!lru_.exists(key)) {
         return;
     }
 
-    const ItemObj &old_item = lru_.get(key);
+    const ItemObj& old_item = lru_.get(key);
     usage_ -= old_item->Size();
 
     SERVER_LOG_DEBUG << "Erase " << key << " size: " << old_item->Size();
@@ -127,7 +120,7 @@ Cache<ItemObj>::erase(const std::string &key) {
     lru_.erase(key);
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 Cache<ItemObj>::clear() {
     std::lock_guard<std::mutex> lock(mutex_);
@@ -137,15 +130,16 @@ Cache<ItemObj>::clear() {
 }
 
 /* free memory space when CACHE occupation exceed its capacity */
-template<typename ItemObj>
+template <typename ItemObj>
 void
 Cache<ItemObj>::free_memory() {
-    if (usage_ <= capacity_) return;
+    if (usage_ <= capacity_)
+        return;
 
     int64_t threshhold = capacity_ * freemem_percent_;
     int64_t delta_size = usage_ - threshhold;
     if (delta_size <= 0) {
-        delta_size = 1;//ensure at least one item erased
+        delta_size = 1;  // ensure at least one item erased
     }
 
     std::set<std::string> key_array;
@@ -156,8 +150,8 @@ Cache<ItemObj>::free_memory() {
 
         auto it = lru_.rbegin();
         while (it != lru_.rend() && released_size < delta_size) {
-            auto &key = it->first;
-            auto &obj_ptr = it->second;
+            auto& key = it->first;
+            auto& obj_ptr = it->second;
 
             key_array.emplace(key);
             released_size += obj_ptr->Size();
@@ -167,14 +161,14 @@ Cache<ItemObj>::free_memory() {
 
     SERVER_LOG_DEBUG << "to be released memory size: " << released_size;
 
-    for (auto &key : key_array) {
+    for (auto& key : key_array) {
         erase(key);
     }
 
     print();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 Cache<ItemObj>::print() {
     size_t cache_count = 0;
@@ -188,7 +182,5 @@ Cache<ItemObj>::print() {
     SERVER_LOG_DEBUG << "[Cache capacity]: " << capacity_ << " bytes";
 }
 
-} // namespace cache
-} // namespace milvus
-
-
+}  // namespace cache
+}  // namespace milvus

core/src/cache/CacheMgr.inl

@@ -15,21 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-
-
 namespace milvus {
 namespace cache {
 
-template<typename ItemObj>
+template <typename ItemObj>
 CacheMgr<ItemObj>::CacheMgr() {
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 CacheMgr<ItemObj>::~CacheMgr() {
-
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 uint64_t
 CacheMgr<ItemObj>::ItemCount() const {
     if (cache_ == nullptr) {
@@ -37,12 +34,12 @@ CacheMgr<ItemObj>::ItemCount() const {
         return 0;
     }
 
-    return (uint64_t) (cache_->size());
+    return (uint64_t)(cache_->size());
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 bool
-CacheMgr<ItemObj>::ItemExists(const std::string &key) {
+CacheMgr<ItemObj>::ItemExists(const std::string& key) {
     if (cache_ == nullptr) {
         SERVER_LOG_ERROR << "Cache doesn't exist";
         return false;
@@ -51,9 +48,9 @@ CacheMgr<ItemObj>::ItemExists(const std::string &key) {
     return cache_->exists(key);
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 ItemObj
-CacheMgr<ItemObj>::GetItem(const std::string &key) {
+CacheMgr<ItemObj>::GetItem(const std::string& key) {
     if (cache_ == nullptr) {
         SERVER_LOG_ERROR << "Cache doesn't exist";
         return nullptr;
@@ -62,9 +59,9 @@ CacheMgr<ItemObj>::GetItem(const std::string &key) {
     return cache_->get(key);
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
-CacheMgr<ItemObj>::InsertItem(const std::string &key, const ItemObj &data) {
+CacheMgr<ItemObj>::InsertItem(const std::string& key, const ItemObj& data) {
     if (cache_ == nullptr) {
         SERVER_LOG_ERROR << "Cache doesn't exist";
         return;
@@ -74,9 +71,9 @@ CacheMgr<ItemObj>::InsertItem(const std::string &key, const ItemObj &data) {
     server::Metrics::GetInstance().CacheAccessTotalIncrement();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
-CacheMgr<ItemObj>::EraseItem(const std::string &key) {
+CacheMgr<ItemObj>::EraseItem(const std::string& key) {
     if (cache_ == nullptr) {
         SERVER_LOG_ERROR << "Cache doesn't exist";
         return;
@@ -86,7 +83,7 @@ CacheMgr<ItemObj>::EraseItem(const std::string &key) {
     server::Metrics::GetInstance().CacheAccessTotalIncrement();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 CacheMgr<ItemObj>::PrintInfo() {
     if (cache_ == nullptr) {
@@ -97,7 +94,7 @@ CacheMgr<ItemObj>::PrintInfo() {
     cache_->print();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 CacheMgr<ItemObj>::ClearCache() {
     if (cache_ == nullptr) {
@@ -108,7 +105,7 @@ CacheMgr<ItemObj>::ClearCache() {
     cache_->clear();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 int64_t
 CacheMgr<ItemObj>::CacheUsage() const {
     if (cache_ == nullptr) {
@@ -119,7 +116,7 @@ CacheMgr<ItemObj>::CacheUsage() const {
     return cache_->usage();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 int64_t
 CacheMgr<ItemObj>::CacheCapacity() const {
     if (cache_ == nullptr) {
@@ -130,7 +127,7 @@ CacheMgr<ItemObj>::CacheCapacity() const {
     return cache_->capacity();
 }
 
-template<typename ItemObj>
+template <typename ItemObj>
 void
 CacheMgr<ItemObj>::SetCapacity(int64_t capacity) {
     if (cache_ == nullptr) {
@@ -140,6 +137,5 @@ CacheMgr<ItemObj>::SetCapacity(int64_t capacity) {
     cache_->set_capacity(capacity);
 }
 
-} // namespace cache
-} // namespace milvus
-
+}  // namespace cache
+}  // namespace milvus

core/src/version.h.macro → core/src/config.h

@@ -15,8 +15,6 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#pragma once
-
-#define MILVUS_VERSION "@MILVUS_VERSION@"
-#define BUILD_TYPE "@BUILD_TYPE@"
-#define BUILD_TIME @BUILD_TIME@
\ No newline at end of file
+#define MILVUS_VERSION "0.5.0"
+#define BUILD_TYPE "Debug"
+#define BUILD_TIME "2019-11-05 18:49.05"

core/src/config.h.in

+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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
+//
+// 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.
+
+#cmakedefine MILVUS_VERSION "@MILVUS_VERSION@"
+#cmakedefine BUILD_TYPE "@BUILD_TYPE@"
+#cmakedefine BUILD_TIME @BUILD_TIME@
\ No newline at end of file

core/src/db/DB.h

@@ -67,16 +67,15 @@ class DB {
 
     virtual Status
     Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-          ResultIds& result_ids, ResultDistances& result_distances) = 0;
+          QueryResults& results) = 0;
 
     virtual Status
     Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-          const meta::DatesT& dates, ResultIds& result_ids, ResultDistances& result_distances) = 0;
+          const meta::DatesT& dates, QueryResults& results) = 0;
 
     virtual Status
     Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
-          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, ResultIds& result_ids,
-          ResultDistances& result_distances) = 0;
+          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) = 0;
 
     virtual Status
     Size(uint64_t& result) = 0;

core/src/db/DBImpl.cpp

@@ -336,20 +336,20 @@ DBImpl::DropIndex(const std::string& table_id) {
 
 Status
 DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-              ResultIds& result_ids, ResultDistances& result_distances) {
+              QueryResults& results) {
     if (shutting_down_.load(std::memory_order_acquire)) {
         return Status(DB_ERROR, "Milsvus server is shutdown!");
     }
 
     meta::DatesT dates = {utils::GetDate()};
-    Status result = Query(table_id, k, nq, nprobe, vectors, dates, result_ids, result_distances);
+    Status result = Query(table_id, k, nq, nprobe, vectors, dates, results);
 
     return result;
 }
 
 Status
 DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-              const meta::DatesT& dates, ResultIds& result_ids, ResultDistances& result_distances) {
+              const meta::DatesT& dates, QueryResults& results) {
     if (shutting_down_.load(std::memory_order_acquire)) {
         return Status(DB_ERROR, "Milsvus server is shutdown!");
     }
@@ -372,15 +372,14 @@ DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t npr
     }
 
     cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info before query
-    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, result_ids, result_distances);
+    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, results);
     cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info after query
     return status;
 }
 
 Status
 DBImpl::Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
-              uint64_t nprobe, const float* vectors, const meta::DatesT& dates, ResultIds& result_ids,
-              ResultDistances& result_distances) {
+              uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) {
     if (shutting_down_.load(std::memory_order_acquire)) {
         return Status(DB_ERROR, "Milsvus server is shutdown!");
     }
@@ -414,7 +413,7 @@ DBImpl::Query(const std::string& table_id, const std::vector<std::string>& file_
     }
 
     cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info before query
-    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, result_ids, result_distances);
+    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, results);
     cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info after query
     return status;
 }
@@ -433,7 +432,7 @@ DBImpl::Size(uint64_t& result) {
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 Status
 DBImpl::QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files, uint64_t k, uint64_t nq,
-                   uint64_t nprobe, const float* vectors, ResultIds& result_ids, ResultDistances& result_distances) {
+                   uint64_t nprobe, const float* vectors, QueryResults& results) {
     server::CollectQueryMetrics metrics(nq);
 
     TimeRecorder rc("");
@@ -454,8 +453,7 @@ DBImpl::QueryAsync(const std::string& table_id, const meta::TableFilesSchema& fi
     }
 
     // step 3: construct results
-    result_ids = job->GetResultIds();
-    result_distances = job->GetResultDistances();
+    results = job->GetResult();
     rc.ElapseFromBegin("Engine query totally cost");
 
     return Status::OK();

core/src/db/DBImpl.h

@@ -91,16 +91,15 @@ class DBImpl : public DB {
 
     Status
     Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-          ResultIds& result_ids, ResultDistances& result_distances) override;
+          QueryResults& results) override;
 
     Status
     Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
-          const meta::DatesT& dates, ResultIds& result_ids, ResultDistances& result_distances) override;
+          const meta::DatesT& dates, QueryResults& results) override;
 
     Status
     Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
-          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, ResultIds& result_ids,
-          ResultDistances& result_distances) override;
+          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) override;
 
     Status
     Size(uint64_t& result) override;
@@ -108,7 +107,7 @@ class DBImpl : public DB {
  private:
     Status
     QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files, uint64_t k, uint64_t nq,
-               uint64_t nprobe, const float* vectors, ResultIds& result_ids, ResultDistances& result_distances);
+               uint64_t nprobe, const float* vectors, QueryResults& results);
 
     void
     BackgroundTimerTask();

core/src/db/Types.h

@@ -19,7 +19,6 @@
 
 #include "db/engine/ExecutionEngine.h"
 
-#include <faiss/Index.h>
 #include <stdint.h>
 #include <utility>
 #include <vector>
@@ -27,13 +26,12 @@
 namespace milvus {
 namespace engine {
 
-using IDNumber = faiss::Index::idx_t;
-
+typedef int64_t IDNumber;
 typedef IDNumber* IDNumberPtr;
 typedef std::vector<IDNumber> IDNumbers;
 
-typedef std::vector<faiss::Index::idx_t> ResultIds;
-typedef std::vector<faiss::Index::distance_t> ResultDistances;
+typedef std::vector<std::pair<IDNumber, double>> QueryResult;
+typedef std::vector<QueryResult> QueryResults;
 
 struct TableIndex {
     int32_t engine_type_ = (int)EngineType::FAISS_IDMAP;

core/src/db/engine/ExecutionEngineImpl.cpp

@@ -25,6 +25,7 @@
 #include "utils/CommonUtil.h"
 #include "utils/Exception.h"
 #include "utils/Log.h"
+
 #include "wrapper/ConfAdapter.h"
 #include "wrapper/ConfAdapterMgr.h"
 #include "wrapper/VecImpl.h"
@@ -92,11 +93,19 @@ ExecutionEngineImpl::CreatetVecIndex(EngineType type) {
             break;
         }
         case EngineType::FAISS_IVFFLAT: {
+#ifdef MILVUS_CPU_VERSION
+            index = GetVecIndexFactory(IndexType::FAISS_IVFFLAT_CPU);
+#else
             index = GetVecIndexFactory(IndexType::FAISS_IVFFLAT_MIX);
+#endif
             break;
         }
         case EngineType::FAISS_IVFSQ8: {
+#ifdef MILVUS_CPU_VERSION
+            index = GetVecIndexFactory(IndexType::FAISS_IVFSQ8_CPU);
+#else
             index = GetVecIndexFactory(IndexType::FAISS_IVFSQ8_MIX);
+#endif
             break;
         }
         case EngineType::NSG_MIX: {
@@ -309,13 +318,30 @@ ExecutionEngineImpl::CopyToGpu(uint64_t device_id, bool hybrid) {
         return Status::OK();
     }
 #endif
-    try {
-        index_ = index_->CopyToGpu(device_id);
-        ENGINE_LOG_DEBUG << "CPU to GPU" << device_id;
-    } catch (std::exception& e) {
-        ENGINE_LOG_ERROR << e.what();
-        return Status(DB_ERROR, e.what());
+
+    auto index = std::static_pointer_cast<VecIndex>(cache::GpuCacheMgr::GetInstance(device_id)->GetIndex(location_));
+    bool already_in_cache = (index != nullptr);
+    if (already_in_cache) {
+        index_ = index;
+    } else {
+        if (index_ == nullptr) {
+            ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to copy to gpu";
+            return Status(DB_ERROR, "index is null");
+        }
+
+        try {
+            index_ = index_->CopyToGpu(device_id);
+            ENGINE_LOG_DEBUG << "CPU to GPU" << device_id;
+        } catch (std::exception& e) {
+            ENGINE_LOG_ERROR << e.what();
+            return Status(DB_ERROR, e.what());
+        }
     }
+
+    if (!already_in_cache) {
+        GpuCache(device_id);
+    }
+
     return Status::OK();
 }
 

core/src/index/CMakeLists.txt

@@ -19,83 +19,96 @@
 
 
 cmake_minimum_required(VERSION 3.14)
-message(STATUS "---------------core--------------")
+message(STATUS "------------------------------KNOWHERE-----------------------------------")
 message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
 
-set(KNOWHERE_VERSION "0.1.0")
+set(KNOWHERE_VERSION "0.5.0")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" KNOWHERE_BASE_VERSION "${KNOWHERE_VERSION}")
-project(knowhere VERSION "${KNOWHERE_BASE_VERSION}" LANGUAGES CUDA C CXX)
+project(knowhere VERSION "${KNOWHERE_BASE_VERSION}" LANGUAGES C CXX)
 set(CMAKE_CXX_STANDARD 14)
 
 set(KNOWHERE_VERSION_MAJOR "${knowhere_VERSION_MAJOR}")
 set(KNOWHERE_VERSION_MINOR "${knowhere_VERSION_MINOR}")
 set(KNOWHERE_VERSION_PATCH "${knowhere_VERSION_PATCH}")
-if(KNOWHERE_VERSION_MAJOR STREQUAL ""
+if (KNOWHERE_VERSION_MAJOR STREQUAL ""
         OR KNOWHERE_VERSION_MINOR STREQUAL ""
         OR KNOWHERE_VERSION_PATCH STREQUAL "")
     message(FATAL_ERROR "Failed to determine Knowhere version from '${KNOWHERE_VERSION}'")
-endif()
+endif ()
 
 message(STATUS "Knowhere version: "
         "${KNOWHERE_VERSION_MAJOR}.${KNOWHERE_VERSION_MINOR}.${KNOWHERE_VERSION_PATCH} "
         "(full: '${KNOWHERE_VERSION}')")
 
 # if no build build type is specified, default to release builds
-if(NOT CMAKE_BUILD_TYPE)
+if (NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
-endif(NOT CMAKE_BUILD_TYPE)
+endif (NOT CMAKE_BUILD_TYPE)
 
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
-else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
-    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
-endif()
-MESSAGE(STATUS "CMAKE_CXX_FLAGS" ${CMAKE_CXX_FLAGS})
-
-find_package(CUDA)
-
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
     message(STATUS "building milvus_engine on x86 architecture")
     set(KNOWHERE_BUILD_ARCH x86_64)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
     message(STATUS "building milvus_engine on ppc architecture")
     set(KNOWHERE_BUILD_ARCH ppc64le)
-else()
+else ()
     message(WARNING "unknown processor type")
     message(WARNING "CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
     set(KNOWHERE_BUILD_ARCH unknown)
-endif()
+endif ()
 
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
     set(BUILD_TYPE "release")
-else()
+else ()
     set(BUILD_TYPE "debug")
-endif()
+endif ()
 message(STATUS "Build type = ${BUILD_TYPE}")
 
 set(INDEX_SOURCE_DIR ${PROJECT_SOURCE_DIR})
 set(INDEX_BINARY_DIR ${PROJECT_BINARY_DIR})
-message(STATUS "Core source dir: ${PROJECT_SOURCE_DIR}")
-message(STATUS "Core binary dir: ${PROJECT_BINARY_DIR}")
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${INDEX_SOURCE_DIR}/cmake")
 
 include(ExternalProject)
 include(DefineOptionsCore)
 include(BuildUtilsCore)
+
+set(KNOWHERE_GPU_VERSION false)
+if (MILVUS_CPU_VERSION OR KNOWHERE_CPU_VERSION)
+    message(STATUS "Building Knowhere CPU version")
+    add_compile_definitions("MILVUS_CPU_VERSION")
+else ()
+    message(STATUS "Building Knowhere GPU version")
+    add_compile_definitions("MILVUS_GPU_VERSION")
+    set(KNOWHERE_GPU_VERSION true)
+    enable_language(CUDA)
+    find_package(CUDA 10 REQUIRED)
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler -fPIC -std=c++11 -D_FORCE_INLINES --expt-extended-lambda")
+endif ()
+
 include(ThirdPartyPackagesCore)
 
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    if (KNOWHERE_GPU_VERSION)
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
+    endif ()
+else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    if (KNOWHERE_GPU_VERSION)
+        set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
+    endif ()
+endif ()
+
 add_subdirectory(knowhere)
 
 if (BUILD_COVERAGE STREQUAL "ON")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-endif()
+endif ()
 
 set(INDEX_INCLUDE_DIRS ${INDEX_INCLUDE_DIRS} PARENT_SCOPE)
 
-if(BUILD_UNIT_TEST STREQUAL "ON")
+if (KNOWHERE_BUILD_TESTS)
     add_subdirectory(unittest)
-endif()
+endif ()
 
 config_summary()

core/src/index/cmake/BuildUtilsCore.cmake

 # Define a function that check last file modification
 function(Check_Last_Modify cache_check_lists_file_path working_dir last_modified_commit_id)
-    if(EXISTS "${working_dir}")
-        if(EXISTS "${cache_check_lists_file_path}")
+    if (EXISTS "${working_dir}")
+        if (EXISTS "${cache_check_lists_file_path}")
             set(GIT_LOG_SKIP_NUM 0)
             set(_MATCH_ALL ON CACHE BOOL "Match all")
             set(_LOOP_STATUS ON CACHE BOOL "Whether out of loop")
             file(STRINGS ${cache_check_lists_file_path} CACHE_IGNORE_TXT)
-            while(_LOOP_STATUS)
-                foreach(_IGNORE_ENTRY ${CACHE_IGNORE_TXT})
-                    if(NOT _IGNORE_ENTRY MATCHES "^[^#]+")
+            while (_LOOP_STATUS)
+                foreach (_IGNORE_ENTRY ${CACHE_IGNORE_TXT})
+                    if (NOT _IGNORE_ENTRY MATCHES "^[^#]+")
                         continue()
-                    endif()
+                    endif ()
 
                     set(_MATCH_ALL OFF)
                     execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --name-status --pretty= WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE CHANGE_FILES)
-                    if(NOT CHANGE_FILES STREQUAL "")
+                    if (NOT CHANGE_FILES STREQUAL "")
                         string(REPLACE "\n" ";" _CHANGE_FILES ${CHANGE_FILES})
-                        foreach(_FILE_ENTRY ${_CHANGE_FILES})
+                        foreach (_FILE_ENTRY ${_CHANGE_FILES})
                             string(REGEX MATCH "[^ \t]+$" _FILE_NAME ${_FILE_ENTRY})
                             execute_process(COMMAND sh -c "echo ${_FILE_NAME} | grep ${_IGNORE_ENTRY}" RESULT_VARIABLE return_code)
                             if (return_code EQUAL 0)
                                 execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
-                                set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                                set(${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
                                 set(_LOOP_STATUS OFF)
-                            endif()
-                        endforeach()
-                    else()
+                            endif ()
+                        endforeach ()
+                    else ()
                         set(_LOOP_STATUS OFF)
-                    endif()
-                endforeach()
+                    endif ()
+                endforeach ()
 
-                if(_MATCH_ALL)
+                if (_MATCH_ALL)
                     execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
-                    set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                    set(${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
                     set(_LOOP_STATUS OFF)
-                endif()
+                endif ()
 
                 math(EXPR GIT_LOG_SKIP_NUM "${GIT_LOG_SKIP_NUM} + 1")
-            endwhile(_LOOP_STATUS)
-        else()
+            endwhile (_LOOP_STATUS)
+        else ()
             execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
-            set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
-        endif()
-    else()
+            set(${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+        endif ()
+    else ()
         message(FATAL_ERROR "The directory ${working_dir} does not exist")
-    endif()
+    endif ()
 endfunction()
 
 # Define a function that extracts a cached package
@@ -83,15 +83,15 @@ endfunction()
 
 # Define a function that to create a new cached package
 function(ExternalProject_Create_Cache project_name package_file install_path cache_username cache_password cache_path)
-    if(EXISTS ${package_file})
+    if (EXISTS ${package_file})
         message(STATUS "Removing existing package file: ${package_file}")
         file(REMOVE ${package_file})
-    endif()
+    endif ()
 
     string(REGEX REPLACE "(.+)/.+$" "\\1" package_dir ${package_file})
-    if(NOT EXISTS ${package_dir})
+    if (NOT EXISTS ${package_dir})
         file(MAKE_DIRECTORY ${package_dir})
-    endif()
+    endif ()
 
     message(STATUS "Will create cached package file: ${package_file}")
 
@@ -116,89 +116,89 @@ function(ADD_THIRDPARTY_LIB LIB_NAME)
             "${one_value_args}"
             "${multi_value_args}"
             ${ARGN})
-    if(ARG_UNPARSED_ARGUMENTS)
+    if (ARG_UNPARSED_ARGUMENTS)
         message(SEND_ERROR "Error: unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}")
-    endif()
+    endif ()
 
-    if(ARG_STATIC_LIB AND ARG_SHARED_LIB)
-        if(NOT ARG_STATIC_LIB)
+    if (ARG_STATIC_LIB AND ARG_SHARED_LIB)
+        if (NOT ARG_STATIC_LIB)
             message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
-        endif()
+        endif ()
 
         set(AUG_LIB_NAME "${LIB_NAME}_static")
         add_library(${AUG_LIB_NAME} STATIC IMPORTED)
         set_target_properties(${AUG_LIB_NAME}
                 PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
-        if(ARG_DEPS)
+        if (ARG_DEPS)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
-        endif()
+        endif ()
         message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
-        if(ARG_INCLUDE_DIRECTORIES)
+        if (ARG_INCLUDE_DIRECTORIES)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
                     "${ARG_INCLUDE_DIRECTORIES}")
-        endif()
+        endif ()
 
         set(AUG_LIB_NAME "${LIB_NAME}_shared")
         add_library(${AUG_LIB_NAME} SHARED IMPORTED)
 
-        if(WIN32)
+        if (WIN32)
             # Mark the ".lib" location as part of a Windows DLL
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
-        else()
+        else ()
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
-        endif()
-        if(ARG_DEPS)
+        endif ()
+        if (ARG_DEPS)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
-        endif()
+        endif ()
         message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
-        if(ARG_INCLUDE_DIRECTORIES)
+        if (ARG_INCLUDE_DIRECTORIES)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
                     "${ARG_INCLUDE_DIRECTORIES}")
-        endif()
-    elseif(ARG_STATIC_LIB)
+        endif ()
+    elseif (ARG_STATIC_LIB)
         set(AUG_LIB_NAME "${LIB_NAME}_static")
         add_library(${AUG_LIB_NAME} STATIC IMPORTED)
         set_target_properties(${AUG_LIB_NAME}
                 PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
-        if(ARG_DEPS)
+        if (ARG_DEPS)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
-        endif()
+        endif ()
         message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
-        if(ARG_INCLUDE_DIRECTORIES)
+        if (ARG_INCLUDE_DIRECTORIES)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
                     "${ARG_INCLUDE_DIRECTORIES}")
-        endif()
-    elseif(ARG_SHARED_LIB)
+        endif ()
+    elseif (ARG_SHARED_LIB)
         set(AUG_LIB_NAME "${LIB_NAME}_shared")
         add_library(${AUG_LIB_NAME} SHARED IMPORTED)
 
-        if(WIN32)
+        if (WIN32)
             # Mark the ".lib" location as part of a Windows DLL
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
-        else()
+        else ()
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
-        endif()
+        endif ()
         message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
-        if(ARG_DEPS)
+        if (ARG_DEPS)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
-        endif()
-        if(ARG_INCLUDE_DIRECTORIES)
+        endif ()
+        if (ARG_INCLUDE_DIRECTORIES)
             set_target_properties(${AUG_LIB_NAME}
                     PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
                     "${ARG_INCLUDE_DIRECTORIES}")
-        endif()
-    else()
+        endif ()
+    else ()
         message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
-    endif()
+    endif ()
 endfunction()

core/src/index/cmake/DefineOptionsCore.cmake

@@ -13,16 +13,16 @@ macro(define_option name description default)
 endmacro()
 
 function(list_join lst glue out)
-    if("${${lst}}" STREQUAL "")
+    if ("${${lst}}" STREQUAL "")
         set(${out} "" PARENT_SCOPE)
         return()
-    endif()
+    endif ()
 
     list(GET ${lst} 0 joined)
     list(REMOVE_AT ${lst} 0)
-    foreach(item ${${lst}})
+    foreach (item ${${lst}})
         set(joined "${joined}${glue}${item}")
-    endforeach()
+    endforeach ()
     set(${out} ${joined} PARENT_SCOPE)
 endfunction()
 
@@ -35,22 +35,31 @@ macro(define_option_string name description default)
 
     set("${name}_OPTION_ENUM" ${ARGN})
     list_join("${name}_OPTION_ENUM" "|" "${name}_OPTION_ENUM")
-    if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+    if (NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
         set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
-    endif()
+    endif ()
 endmacro()
 
+#----------------------------------------------------------------------
+set_option_category("CPU version")
+
+if (MILVUS_CPU_VERSION)
+    define_option(KNOWHERE_CPU_VERSION "Build CPU version only" ON)
+else ()
+    define_option(KNOWHERE_CPU_VERSION "Build CPU version only" OFF)
+endif ()
+
 #----------------------------------------------------------------------
 set_option_category("Thirdparty")
 
 set(KNOWHERE_DEPENDENCY_SOURCE_DEFAULT "AUTO")
 
 define_option_string(KNOWHERE_DEPENDENCY_SOURCE
-                    "Method to use for acquiring KNOWHERE's build dependencies"
-                    "${KNOWHERE_DEPENDENCY_SOURCE_DEFAULT}"
-                    "AUTO"
-                    "BUNDLED"
-                    "SYSTEM")
+        "Method to use for acquiring KNOWHERE's build dependencies"
+        "${KNOWHERE_DEPENDENCY_SOURCE_DEFAULT}"
+        "AUTO"
+        "BUNDLED"
+        "SYSTEM")
 
 define_option(KNOWHERE_VERBOSE_THIRDPARTY_BUILD
         "Show output from ExternalProjects rather than just logging to files" ON)
@@ -70,10 +79,10 @@ define_option(KNOWHERE_WITH_FAISS "Build with FAISS library" ON)
 
 define_option(KNOWHERE_WITH_FAISS_GPU_VERSION "Build with FAISS GPU version" ON)
 
-define_option(KNOWHERE_WITH_OPENBLAS "Build with OpenBLAS library" ON)
+define_option(BUILD_FAISS_WITH_MKL "Build FAISS with MKL" OFF)
 
 #----------------------------------------------------------------------
-if(MSVC)
+if (MSVC)
     set_option_category("MSVC")
 
     define_option(MSVC_LINK_VERBOSE
@@ -81,16 +90,16 @@ if(MSVC)
             OFF)
 
     define_option(KNOWHERE_USE_STATIC_CRT "Build KNOWHERE with statically linked CRT" OFF)
-endif()
+endif ()
 
 #----------------------------------------------------------------------
 set_option_category("Test and benchmark")
 
 if (BUILD_UNIT_TEST)
     define_option(KNOWHERE_BUILD_TESTS "Build the KNOWHERE googletest unit tests" ON)
-else()
+else ()
     define_option(KNOWHERE_BUILD_TESTS "Build the KNOWHERE googletest unit tests" OFF)
-endif(BUILD_UNIT_TEST)
+endif (BUILD_UNIT_TEST)
 
 #----------------------------------------------------------------------
 macro(config_summary)
@@ -102,12 +111,12 @@ macro(config_summary)
     message(STATUS "  Generator: ${CMAKE_GENERATOR}")
     message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
     message(STATUS "  Source directory: ${CMAKE_CURRENT_SOURCE_DIR}")
-    if(${CMAKE_EXPORT_COMPILE_COMMANDS})
+    if (${CMAKE_EXPORT_COMPILE_COMMANDS})
         message(
                 STATUS "  Compile commands: ${INDEX_BINARY_DIR}/compile_commands.json")
-    endif()
+    endif ()
 
-    foreach(category ${KNOWHERE_OPTION_CATEGORIES})
+    foreach (category ${KNOWHERE_OPTION_CATEGORIES})
 
         message(STATUS)
         message(STATUS "${category} options:")
@@ -115,50 +124,50 @@ macro(config_summary)
         set(option_names ${KNOWHERE_${category}_OPTION_NAMES})
 
         set(max_value_length 0)
-        foreach(name ${option_names})
+        foreach (name ${option_names})
             string(LENGTH "\"${${name}}\"" value_length)
-            if(${max_value_length} LESS ${value_length})
+            if (${max_value_length} LESS ${value_length})
                 set(max_value_length ${value_length})
-            endif()
-        endforeach()
+            endif ()
+        endforeach ()
 
-        foreach(name ${option_names})
-            if("${${name}_OPTION_TYPE}" STREQUAL "string")
+        foreach (name ${option_names})
+            if ("${${name}_OPTION_TYPE}" STREQUAL "string")
                 set(value "\"${${name}}\"")
-            else()
+            else ()
                 set(value "${${name}}")
-            endif()
+            endif ()
 
             set(default ${${name}_OPTION_DEFAULT})
             set(description ${${name}_OPTION_DESCRIPTION})
             string(LENGTH ${description} description_length)
-            if(${description_length} LESS 70)
+            if (${description_length} LESS 70)
                 string(
                         SUBSTRING
                         "                                                                     "
                         ${description_length} -1 description_padding)
-            else()
+            else ()
                 set(description_padding "
                 ")
-            endif()
+            endif ()
 
             set(comment "[${name}]")
 
-            if("${value}" STREQUAL "${default}")
+            if ("${value}" STREQUAL "${default}")
                 set(comment "[default] ${comment}")
-            endif()
+            endif ()
 
-            if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+            if (NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
                 set(comment "${comment} [${${name}_OPTION_ENUM}]")
-            endif()
+            endif ()
 
             string(
                     SUBSTRING "${value}                                                             "
                     0 ${max_value_length} value)
 
             message(STATUS "  ${description} ${description_padding} ${value} ${comment}")
-        endforeach()
+        endforeach ()
 
-    endforeach()
+    endforeach ()
 
 endmacro()

core/src/index/knowhere/CMakeLists.txt

-include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
-link_directories(${CUDA_TOOLKIT_ROOT_DIR}/lib64)
-
 include_directories(${INDEX_SOURCE_DIR}/knowhere)
 include_directories(${INDEX_SOURCE_DIR}/thirdparty)
 include_directories(${INDEX_SOURCE_DIR}/thirdparty/SPTAG/AnnService)
@@ -19,9 +16,9 @@ file(GLOB SRC_FILES
         ${SPTAG_SOURCE_DIR}/AnnService/src/Core/KDT/*.cpp
         ${SPTAG_SOURCE_DIR}/AnnService/src/Helper/*.cpp)
 
-if(NOT TARGET SPTAGLibStatic)
+if (NOT TARGET SPTAGLibStatic)
     add_library(SPTAGLibStatic STATIC ${SRC_FILES} ${HDR_FILES})
-endif()
+endif ()
 
 set(external_srcs
         knowhere/adapter/SptagAdapter.cpp
@@ -36,19 +33,13 @@ set(index_srcs
         knowhere/index/vector_index/IndexKDT.cpp
         knowhere/index/vector_index/IndexIDMAP.cpp
         knowhere/index/vector_index/IndexIVF.cpp
-        knowhere/index/vector_index/IndexGPUIVF.cpp
         knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
         knowhere/index/vector_index/IndexNSG.cpp
         knowhere/index/vector_index/nsg/NSG.cpp
         knowhere/index/vector_index/nsg/NSGIO.cpp
         knowhere/index/vector_index/nsg/NSGHelper.cpp
-        knowhere/index/vector_index/helpers/Cloner.cpp
-        knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
         knowhere/index/vector_index/IndexIVFSQ.cpp
-        knowhere/index/vector_index/IndexGPUIVFSQ.cpp
-        knowhere/index/vector_index/IndexIVFSQHybrid.cpp
         knowhere/index/vector_index/IndexIVFPQ.cpp
-        knowhere/index/vector_index/IndexGPUIVFPQ.cpp
         knowhere/index/vector_index/FaissBaseIndex.cpp
         knowhere/index/vector_index/helpers/FaissIO.cpp
         knowhere/index/vector_index/helpers/IndexParameter.cpp
@@ -57,24 +48,56 @@ set(index_srcs
 set(depend_libs
         SPTAGLibStatic
         faiss
-        openblas
-        lapack
         arrow
         ${ARROW_PREFIX}/lib/libjemalloc_pic.a
-        cudart
-        cublas
         gomp
         gfortran
         pthread
         )
+if (BUILD_FAISS_WITH_MKL)
+    set(depend_libs ${depend_libs}
+            "-Wl,--start-group \
+            ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \
+            ${MKL_LIB_PATH}/libmkl_gnu_thread.a \
+            ${MKL_LIB_PATH}/libmkl_core.a \
+            -Wl,--end-group -lgomp -lpthread -lm -ldl"
+            )
+else ()
+    set(depend_libs ${depend_libs}
+            lapack
+            openblas)
+endif ()
+
+if (KNOWHERE_GPU_VERSION)
+    include_directories(${CUDA_INCLUDE_DIRS})
+    link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+    set(cuda_lib
+            cudart
+            cublas
+            )
+    set(depend_libs ${depend_libs}
+            ${cuda_lib}
+            )
+
+    set(index_srcs ${index_srcs}
+            knowhere/index/vector_index/IndexGPUIVF.cpp
+            knowhere/index/vector_index/helpers/Cloner.cpp
+            knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
+            knowhere/index/vector_index/IndexGPUIVFSQ.cpp
+            knowhere/index/vector_index/IndexIVFSQHybrid.cpp
+            knowhere/index/vector_index/IndexGPUIVFPQ.cpp
+            knowhere/index/vector_index/IndexGPUIDMAP.cpp
+            )
+
+endif ()
 
-if(NOT TARGET knowhere)
+if (NOT TARGET knowhere)
     add_library(
             knowhere STATIC
             ${external_srcs}
             ${index_srcs}
     )
-endif()
+endif ()
 
 target_link_libraries(
         knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIDMAP.cpp

+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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
+//
+// 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.
+
+#include "knowhere/index/vector_index/IndexGPUIDMAP.h"
+
+#include <faiss/AutoTune.h>
+#include <faiss/IndexFlat.h>
+#include <faiss/MetaIndexes.h>
+#include <faiss/index_io.h>
+
+#ifdef MILVUS_GPU_VERSION
+
+#include <faiss/gpu/GpuCloner.h>
+
+#endif
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+
+VectorIndexPtr
+GPUIDMAP::CopyGpuToCpu(const Config& config) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    faiss::Index* device_index = index_.get();
+    faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+    std::shared_ptr<faiss::Index> new_index;
+    new_index.reset(host_index);
+    return std::make_shared<IDMAP>(new_index);
+}
+
+VectorIndexPtr
+GPUIDMAP::Clone() {
+    auto cpu_idx = CopyGpuToCpu(Config());
+
+    if (auto idmap = std::dynamic_pointer_cast<IDMAP>(cpu_idx)) {
+        return idmap->CopyCpuToGpu(gpu_id_, Config());
+    } else {
+        KNOWHERE_THROW_MSG("IndexType not Support GpuClone");
+    }
+}
+
+BinarySet
+GPUIDMAP::SerializeImpl() {
+    try {
+        MemoryIOWriter writer;
+        {
+            faiss::Index* index = index_.get();
+            faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(index);
+
+            faiss::write_index(host_index, &writer);
+            delete host_index;
+        }
+        auto data = std::make_shared<uint8_t>();
+        data.reset(writer.data_);
+
+        BinarySet res_set;
+        res_set.Append("IVF", data, writer.rp);
+
+        return res_set;
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+void
+GPUIDMAP::LoadImpl(const BinarySet& index_binary) {
+    auto binary = index_binary.GetByName("IVF");
+    MemoryIOReader reader;
+    {
+        reader.total = binary->size;
+        reader.data_ = binary->data.get();
+
+        faiss::Index* index = faiss::read_index(&reader);
+
+        if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+            ResScope rs(res, gpu_id_, false);
+            auto device_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), gpu_id_, index);
+            index_.reset(device_index);
+            res_ = res;
+        } else {
+            KNOWHERE_THROW_MSG("Load error, can't get gpu resource");
+        }
+
+        delete index;
+    }
+}
+
+VectorIndexPtr
+GPUIDMAP::CopyGpuToGpu(const int64_t& device_id, const Config& config) {
+    auto cpu_index = CopyGpuToCpu(config);
+    return std::static_pointer_cast<IDMAP>(cpu_index)->CopyCpuToGpu(device_id, config);
+}
+
+float*
+GPUIDMAP::GetRawVectors() {
+    KNOWHERE_THROW_MSG("Not support");
+}
+
+int64_t*
+GPUIDMAP::GetRawIds() {
+    KNOWHERE_THROW_MSG("Not support");
+}
+
+void
+GPUIDMAP::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+    ResScope rs(res_, gpu_id_);
+    index_->search(n, (float*)data, k, distances, labels);
+}
+
+}  // namespace knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIDMAP.h

+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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
+//
+// 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.
+
+#pragma once
+
+#include "IndexGPUIVF.h"
+#include "IndexIDMAP.h"
+#include "IndexIVF.h"
+
+#include <memory>
+#include <utility>
+
+namespace knowhere {
+
+class GPUIDMAP : public IDMAP, public GPUIndex {
+ public:
+    explicit GPUIDMAP(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& res)
+        : IDMAP(std::move(index)), GPUIndex(device_id, res) {
+    }
+
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+
+    float*
+    GetRawVectors() override;
+
+    int64_t*
+    GetRawIds() override;
+
+    VectorIndexPtr
+    Clone() override;
+
+    VectorIndexPtr
+    CopyGpuToGpu(const int64_t& device_id, const Config& config) override;
+
+ protected:
+    void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
+
+    BinarySet
+    SerializeImpl() override;
+
+    void
+    LoadImpl(const BinarySet& index_binary) override;
+};
+
+using GPUIDMAPPtr = std::shared_ptr<GPUIDMAP>;
+
+}  // namespace knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp

@@ -17,10 +17,18 @@
 
 #include <faiss/IndexFlat.h>
 #include <faiss/MetaIndexes.h>
-#include <faiss/gpu/GpuCloner.h>
+
+#include <faiss/AutoTune.h>
+#include <faiss/clone_index.h>
 #include <faiss/index_factory.h>
 #include <faiss/index_io.h>
 
+#ifdef MILVUS_GPU_VERSION
+
+#include <faiss/gpu/GpuCloner.h>
+
+#endif
+
 #include <vector>
 
 #include "knowhere/adapter/VectorAdapter.h"
@@ -28,6 +36,13 @@
 #include "knowhere/index/vector_index/IndexIDMAP.h"
 #include "knowhere/index/vector_index/helpers/FaissIO.h"
 
+#ifdef MILVUS_GPU_VERSION
+
+#include "knowhere/index/vector_index/IndexGPUIDMAP.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+
+#endif
+
 namespace knowhere {
 
 BinarySet
@@ -160,6 +175,8 @@ IDMAP::Clone() {
 
 VectorIndexPtr
 IDMAP::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+#ifdef MILVUS_GPU_VERSION
+
     if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
         ResScope rs(res, device_id, false);
         auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get());
@@ -170,6 +187,9 @@ IDMAP::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
     } else {
         KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
     }
+#else
+    KNOWHERE_THROW_MSG("Calling IDMAP::CopyCpuToGpu when we are using CPU version");
+#endif
 }
 
 void
@@ -177,95 +197,4 @@ IDMAP::Seal() {
     // do nothing
 }
 
-VectorIndexPtr
-GPUIDMAP::CopyGpuToCpu(const Config& config) {
-    std::lock_guard<std::mutex> lk(mutex_);
-
-    faiss::Index* device_index = index_.get();
-    faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
-
-    std::shared_ptr<faiss::Index> new_index;
-    new_index.reset(host_index);
-    return std::make_shared<IDMAP>(new_index);
-}
-
-VectorIndexPtr
-GPUIDMAP::Clone() {
-    auto cpu_idx = CopyGpuToCpu(Config());
-
-    if (auto idmap = std::dynamic_pointer_cast<IDMAP>(cpu_idx)) {
-        return idmap->CopyCpuToGpu(gpu_id_, Config());
-    } else {
-        KNOWHERE_THROW_MSG("IndexType not Support GpuClone");
-    }
-}
-
-BinarySet
-GPUIDMAP::SerializeImpl() {
-    try {
-        MemoryIOWriter writer;
-        {
-            faiss::Index* index = index_.get();
-            faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(index);
-
-            faiss::write_index(host_index, &writer);
-            delete host_index;
-        }
-        auto data = std::make_shared<uint8_t>();
-        data.reset(writer.data_);
-
-        BinarySet res_set;
-        res_set.Append("IVF", data, writer.rp);
-
-        return res_set;
-    } catch (std::exception& e) {
-        KNOWHERE_THROW_MSG(e.what());
-    }
-}
-
-void
-GPUIDMAP::LoadImpl(const BinarySet& index_binary) {
-    auto binary = index_binary.GetByName("IVF");
-    MemoryIOReader reader;
-    {
-        reader.total = binary->size;
-        reader.data_ = binary->data.get();
-
-        faiss::Index* index = faiss::read_index(&reader);
-
-        if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
-            ResScope rs(res, gpu_id_, false);
-            auto device_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), gpu_id_, index);
-            index_.reset(device_index);
-            res_ = res;
-        } else {
-            KNOWHERE_THROW_MSG("Load error, can't get gpu resource");
-        }
-
-        delete index;
-    }
-}
-
-VectorIndexPtr
-GPUIDMAP::CopyGpuToGpu(const int64_t& device_id, const Config& config) {
-    auto cpu_index = CopyGpuToCpu(config);
-    return std::static_pointer_cast<IDMAP>(cpu_index)->CopyCpuToGpu(device_id, config);
-}
-
-float*
-GPUIDMAP::GetRawVectors() {
-    KNOWHERE_THROW_MSG("Not support");
-}
-
-int64_t*
-GPUIDMAP::GetRawIds() {
-    KNOWHERE_THROW_MSG("Not support");
-}
-
-void
-GPUIDMAP::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
-    ResScope rs(res_, gpu_id_);
-    index_->search(n, (float*)data, k, distances, labels);
-}
-
 }  // namespace knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.h

@@ -17,7 +17,6 @@
 
 #pragma once
 
-#include "IndexGPUIVF.h"
 #include "IndexIVF.h"
 
 #include <memory>
@@ -67,32 +66,4 @@ class IDMAP : public VectorIndex, public FaissBaseIndex {
 
 using IDMAPPtr = std::shared_ptr<IDMAP>;
 
-class GPUIDMAP : public IDMAP, public GPUIndex {
- public:
-    explicit GPUIDMAP(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& res)
-        : IDMAP(std::move(index)), GPUIndex(device_id, res) {
-    }
-
-    VectorIndexPtr
-    CopyGpuToCpu(const Config& config) override;
-    float*
-    GetRawVectors() override;
-    int64_t*
-    GetRawIds() override;
-    VectorIndexPtr
-    Clone() override;
-    VectorIndexPtr
-    CopyGpuToGpu(const int64_t& device_id, const Config& config) override;
-
- protected:
-    void
-    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
-    BinarySet
-    SerializeImpl() override;
-    void
-    LoadImpl(const BinarySet& index_binary) override;
-};
-
-using GPUIDMAPPtr = std::shared_ptr<GPUIDMAP>;
-
 }  // namespace knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.cpp

@@ -15,11 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <faiss/AutoTune.h>
 #include <faiss/IVFlib.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexIVF.h>
 #include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexIVFPQ.h>
+#include <faiss/clone_index.h>
+#include <faiss/index_factory.h>
+#include <faiss/index_io.h>
+#ifdef MILVUS_GPU_VERSION
+#include <faiss/gpu/GpuAutoTune.h>
 #include <faiss/gpu/GpuCloner.h>
+#endif
 
 #include <chrono>
 #include <memory>
@@ -29,7 +37,9 @@
 #include "knowhere/adapter/VectorAdapter.h"
 #include "knowhere/common/Exception.h"
 #include "knowhere/common/Log.h"
+#ifdef MILVUS_GPU_VERSION
 #include "knowhere/index/vector_index/IndexGPUIVF.h"
+#endif
 #include "knowhere/index/vector_index/IndexIVF.h"
 
 namespace knowhere {
@@ -221,16 +231,17 @@ IVF::search_impl(int64_t n, const float* data, int64_t k, float* distances, int6
     faiss::ivflib::search_with_parameters(index_.get(), n, (float*)data, k, distances, labels, params.get());
     stdclock::time_point after = stdclock::now();
     double search_cost = (std::chrono::duration<double, std::micro>(after - before)).count();
-    KNOWHERE_LOG_DEBUG << "K=" << k << " NQ=" << n << " NL=" << faiss::indexIVF_stats.nlist
-                       << " ND=" << faiss::indexIVF_stats.ndis << " NH=" << faiss::indexIVF_stats.nheap_updates
-                       << " Q=" << faiss::indexIVF_stats.quantization_time
-                       << " S=" << faiss::indexIVF_stats.search_time;
+    KNOWHERE_LOG_DEBUG << "IVF search cost: " << search_cost
+                       << ", quantization cost: " << faiss::indexIVF_stats.quantization_time
+                       << ", data search cost: " << faiss::indexIVF_stats.search_time;
     faiss::indexIVF_stats.quantization_time = 0;
     faiss::indexIVF_stats.search_time = 0;
 }
 
 VectorIndexPtr
 IVF::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+#ifdef MILVUS_GPU_VERSION
+
     if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
         ResScope rs(res, device_id, false);
         auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get());
@@ -241,6 +252,10 @@ IVF::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
     } else {
         KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
     }
+
+#else
+    KNOWHERE_THROW_MSG("Calling IVF::CopyCpuToGpu when we are using CPU version");
+#endif
 }
 
 VectorIndexPtr

core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp

@@ -15,15 +15,22 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#ifdef MILVUS_GPU_VERSION
+#include <faiss/gpu/GpuAutoTune.h>
 #include <faiss/gpu/GpuCloner.h>
+#endif
 #include <faiss/index_factory.h>
+
 #include <memory>
 
 #include "knowhere/adapter/VectorAdapter.h"
 #include "knowhere/common/Exception.h"
-#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
 #include "knowhere/index/vector_index/IndexIVFSQ.h"
+
+#ifdef MILVUS_GPU_VERSION
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
 #include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#endif
 
 namespace knowhere {
 
@@ -54,6 +61,8 @@ IVFSQ::Clone_impl(const std::shared_ptr<faiss::Index>& index) {
 
 VectorIndexPtr
 IVFSQ::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+#ifdef MILVUS_GPU_VERSION
+
     if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
         ResScope rs(res, device_id, false);
 
@@ -65,6 +74,10 @@ IVFSQ::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
     } else {
         KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
     }
+
+#else
+    KNOWHERE_THROW_MSG("Calling IVFSQ::CopyCpuToGpu when we are using CPU version");
+#endif
 }
 
 }  // namespace knowhere

core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.cpp

@@ -19,8 +19,10 @@
 #include "knowhere/adapter/VectorAdapter.h"
 #include "knowhere/common/Exception.h"
 #include "knowhere/common/Timer.h"
+#ifdef MILVUS_GPU_VERSION
 #include "knowhere/index/vector_index/IndexGPUIVF.h"
-#include "knowhere/index/vector_index/IndexIDMAP.h"
+#endif
+
 #include "knowhere/index/vector_index/IndexIVF.h"
 #include "knowhere/index/vector_index/nsg/NSG.h"
 #include "knowhere/index/vector_index/nsg/NSGIO.h"
@@ -117,7 +119,11 @@ NSG::Train(const DatasetPtr& dataset, const Config& config) {
     }
 
     // TODO(linxj): dev IndexFactory, support more IndexType
+#ifdef MILVUS_GPU_VERSION
     auto preprocess_index = std::make_shared<GPUIVF>(build_cfg->gpu_id);
+#else
+    auto preprocess_index = std::make_shared<IVF>();
+#endif
     auto model = preprocess_index->Train(dataset, config);
     preprocess_index->set_index_model(model);
     preprocess_index->AddWithoutIds(dataset, config);

core/src/index/unittest/CMakeLists.txt

@@ -2,26 +2,32 @@ include_directories(${INDEX_SOURCE_DIR}/thirdparty)
 include_directories(${INDEX_SOURCE_DIR}/thirdparty/SPTAG/AnnService)
 include_directories(${INDEX_SOURCE_DIR}/knowhere)
 include_directories(${INDEX_SOURCE_DIR})
-include_directories(/usr/local/cuda/include)
-link_directories(/usr/local/cuda/lib64)
-
-message(STATUS "arrow prefix: ${ARROW_PREFIX}")
-message(STATUS "libjemalloc_pic path: ${ARROW_PREFIX}/lib/libjemalloc_pic.a")
 
 set(depend_libs
         gtest gmock gtest_main gmock_main
-        faiss openblas lapack
+        faiss
         arrow "${ARROW_PREFIX}/lib/libjemalloc_pic.a"
         )
+if (BUILD_FAISS_WITH_MKL)
+    set(depend_libs ${depend_libs}
+            "-Wl,--start-group \
+            ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \
+            ${MKL_LIB_PATH}/libmkl_gnu_thread.a \
+            ${MKL_LIB_PATH}/libmkl_core.a \
+            -Wl,--end-group -lgomp -lpthread -lm -ldl"
+            )
+else ()
+    set(depend_libs ${depend_libs}
+            lapack
+            openblas)
+endif ()
 
 set(basic_libs
-        cudart cublas
         gomp gfortran pthread
         )
 
 set(util_srcs
         ${MILVUS_ENGINE_SRC}/external/easyloggingpp/easylogging++.cc
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/adapter/Structure.cpp
@@ -31,32 +37,49 @@ set(util_srcs
         ${INDEX_SOURCE_DIR}/unittest/utils.cpp
         )
 
+if (KNOWHERE_GPU_VERSION)
+    include_directories(${CUDA_INCLUDE_DIRS})
+    link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+    set(cuda_lib
+            cudart
+            cublas
+            )
+    set(basic_libs ${basic_libs}
+            ${cuda_lib}
+            )
+    set(util_srcs ${util_srcs}
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
+            )
+endif ()
+
 #<IVF-TEST>
 set(ivf_srcs
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVF.cpp
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFPQ.cpp
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/FaissBaseIndex.cpp
         )
-if(NOT TARGET test_ivf)
+if (KNOWHERE_GPU_VERSION)
+    set(ivf_srcs ${ivf_srcs}
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIDMAP.cpp
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp
+            ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp
+            )
+endif ()
+if (NOT TARGET test_ivf)
     add_executable(test_ivf test_ivf.cpp ${ivf_srcs} ${util_srcs})
-endif()
+endif ()
 target_link_libraries(test_ivf ${depend_libs} ${unittest_libs} ${basic_libs})
 
 
 #<IDMAP-TEST>
-set(idmap_srcs
-        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
-        )
-if(NOT TARGET test_idmap)
-    add_executable(test_idmap test_idmap.cpp ${idmap_srcs} ${ivf_srcs} ${util_srcs})
-endif()
+if (NOT TARGET test_idmap)
+    add_executable(test_idmap test_idmap.cpp ${ivf_srcs} ${util_srcs})
+endif ()
 target_link_libraries(test_idmap ${depend_libs} ${unittest_libs} ${basic_libs})
 
 #<KDT-TEST>
@@ -66,25 +89,28 @@ set(kdt_srcs
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexKDT.cpp
         )
-if(NOT TARGET test_kdt)
+if (NOT TARGET test_kdt)
     add_executable(test_kdt test_kdt.cpp ${kdt_srcs} ${util_srcs})
-endif()
+endif ()
 target_link_libraries(test_kdt
         SPTAGLibStatic
         ${depend_libs} ${unittest_libs} ${basic_libs})
 
-add_executable(test_gpuresource test_gpuresource.cpp ${util_srcs} ${ivf_srcs})
-target_link_libraries(test_gpuresource ${depend_libs} ${unittest_libs} ${basic_libs})
+if (KNOWHERE_GPU_VERSION)
+    add_executable(test_gpuresource test_gpuresource.cpp ${util_srcs} ${ivf_srcs})
+    target_link_libraries(test_gpuresource ${depend_libs} ${unittest_libs} ${basic_libs})
 
-add_executable(test_customized_index test_customized_index.cpp ${util_srcs} ${ivf_srcs})
-target_link_libraries(test_customized_index ${depend_libs} ${unittest_libs} ${basic_libs})
+    add_executable(test_customized_index test_customized_index.cpp ${util_srcs} ${ivf_srcs})
+    target_link_libraries(test_customized_index ${depend_libs} ${unittest_libs} ${basic_libs})
+endif ()
 
 install(TARGETS test_ivf DESTINATION unittest)
 install(TARGETS test_idmap DESTINATION unittest)
 install(TARGETS test_kdt DESTINATION unittest)
-install(TARGETS test_gpuresource DESTINATION unittest)
-install(TARGETS test_customized_index DESTINATION unittest)
-
+if (KNOWHERE_GPU_VERSION)
+    install(TARGETS test_gpuresource DESTINATION unittest)
+    install(TARGETS test_customized_index DESTINATION unittest)
+endif ()
 #add_subdirectory(faiss_ori)
 #add_subdirectory(faiss_benchmark)
 add_subdirectory(test_nsg)

core/src/index/unittest/Helper.h

@@ -18,13 +18,16 @@
 #include <memory>
 #include <string>
 
-#include "knowhere/index/vector_index/IndexGPUIVF.h"
-#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
-#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
 #include "knowhere/index/vector_index/IndexIVF.h"
 #include "knowhere/index/vector_index/IndexIVFPQ.h"
 #include "knowhere/index/vector_index/IndexIVFSQ.h"
+
+#ifdef MILVUS_GPU_VERSION
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
 #include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#endif
 
 int DEVICEID = 0;
 constexpr int64_t DIM = 128;
@@ -41,16 +44,18 @@ IndexFactory(const std::string& type) {
         return std::make_shared<knowhere::IVF>();
     } else if (type == "IVFPQ") {
         return std::make_shared<knowhere::IVFPQ>();
+    } else if (type == "IVFSQ") {
+        return std::make_shared<knowhere::IVFSQ>();
+#ifdef MILVUS_GPU_VERSION
     } else if (type == "GPUIVF") {
         return std::make_shared<knowhere::GPUIVF>(DEVICEID);
     } else if (type == "GPUIVFPQ") {
         return std::make_shared<knowhere::GPUIVFPQ>(DEVICEID);
-    } else if (type == "IVFSQ") {
-        return std::make_shared<knowhere::IVFSQ>();
     } else if (type == "GPUIVFSQ") {
         return std::make_shared<knowhere::GPUIVFSQ>(DEVICEID);
     } else if (type == "IVFSQHybrid") {
         return std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+#endif
     }
 }
 
@@ -110,11 +115,15 @@ class TestGpuIndexBase : public ::testing::Test {
  protected:
     void
     SetUp() override {
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
+#endif
     }
 
     void
     TearDown() override {
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().Free();
+#endif
     }
 };

core/src/index/unittest/faiss_benchmark/CMakeLists.txt

-include_directories(${INDEX_SOURCE_DIR}/thirdparty)
-include_directories(${INDEX_SOURCE_DIR}/include)
-include_directories(/usr/local/cuda/include)
-include_directories(/usr/local/hdf5/include)
-
-link_directories(/usr/local/cuda/lib64)
-link_directories(/usr/local/hdf5/lib)
-
-set(unittest_libs
-        gtest gmock gtest_main gmock_main)
-
-set(depend_libs
-        faiss openblas lapack hdf5
-        arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
-        )
-
-set(basic_libs
-        cudart cublas
-        gomp gfortran pthread
-        )
-
-add_executable(test_faiss_benchmark faiss_benchmark_test.cpp)
-target_link_libraries(test_faiss_benchmark ${depend_libs} ${unittest_libs} ${basic_libs})
-install(TARGETS test_faiss_benchmark DESTINATION unittest)
+if (KNOWHERE_GPU_VERSION)
+
+    include_directories(${INDEX_SOURCE_DIR}/thirdparty)
+    include_directories(${INDEX_SOURCE_DIR}/include)
+    include_directories(/usr/local/cuda/include)
+    include_directories(/usr/local/hdf5/include)
+
+    link_directories(/usr/local/cuda/lib64)
+    link_directories(/usr/local/hdf5/lib)
+
+    set(unittest_libs
+            gtest gmock gtest_main gmock_main)
+
+    set(depend_libs
+            faiss hdf5
+            arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+            )
+    if (BUILD_FAISS_WITH_MKL)
+        set(depend_libs ${depend_libs}
+                "-Wl,--start-group \
+                ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \
+                ${MKL_LIB_PATH}/libmkl_gnu_thread.a \
+                ${MKL_LIB_PATH}/libmkl_core.a \
+                -Wl,--end-group -lgomp -lpthread -lm -ldl"
+                )
+    else ()
+        set(depend_libs ${depend_libs}
+                lapack
+                openblas)
+    endif ()
+
+    set(basic_libs
+            gomp gfortran pthread
+            )
+
+    include_directories(${CUDA_INCLUDE_DIRS})
+    link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+    set(cuda_lib
+            cudart
+            cublas
+            )
+    set(basic_libs ${basic_libs}
+            ${cuda_lib}
+            )
+
+    add_executable(test_faiss_benchmark faiss_benchmark_test.cpp)
+    target_link_libraries(test_faiss_benchmark ${depend_libs} ${unittest_libs} ${basic_libs})
+    install(TARGETS test_faiss_benchmark DESTINATION unittest)
+
+endif ()

core/src/index/unittest/faiss_ori/CMakeLists.txt

-include_directories(${INDEX_SOURCE_DIR}/thirdparty)
-include_directories(${INDEX_SOURCE_DIR}/include)
-include_directories(/usr/local/cuda/include)
-link_directories(/usr/local/cuda/lib64)
+if (KNOWHERE_GPU_VERSION)
 
-set(unittest_libs
-        gtest gmock gtest_main gmock_main)
+    include_directories(${INDEX_SOURCE_DIR}/thirdparty)
+    include_directories(${INDEX_SOURCE_DIR}/include)
 
-set(depend_libs
-        faiss openblas lapack
-        arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
-        )
+    set(unittest_libs
+            gtest gmock gtest_main gmock_main)
 
-set(basic_libs
-        cudart cublas
-        gomp gfortran pthread
-        )
+    set(depend_libs
+            faiss
+            arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+            )
+    if (BUILD_FAISS_WITH_MKL)
+        set(depend_libs ${depend_libs}
+                "-Wl,--start-group \
+                ${MKL_LIB_PATH}/libmkl_intel_ilp64.a \
+                ${MKL_LIB_PATH}/libmkl_gnu_thread.a \
+                ${MKL_LIB_PATH}/libmkl_core.a \
+                -Wl,--end-group -lgomp -lpthread -lm -ldl"
+                )
+    else ()
+        set(depend_libs ${depend_libs}
+                lapack
+                openblas)
+    endif ()
 
+    set(basic_libs
+            gomp gfortran pthread
+            )
 
-#<GPU-TEST>
-if(NOT TARGET test_gpu)
-    add_executable(test_gpu gpuresource_test.cpp)
-endif()
-target_link_libraries(test_gpu ${depend_libs} ${unittest_libs} ${basic_libs})
+    include_directories(${CUDA_INCLUDE_DIRS})
+    link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+    set(cuda_lib
+            cudart
+            cublas
+            )
+    set(basic_libs ${basic_libs}
+            ${cuda_lib}
+            )
 
-install(TARGETS test_gpu DESTINATION unittest)
\ No newline at end of file
+    #<GPU-TEST>
+    if (NOT TARGET test_gpu)
+        add_executable(test_gpu gpuresource_test.cpp)
+    endif ()
+    target_link_libraries(test_gpu ${depend_libs} ${unittest_libs} ${basic_libs})
+
+    install(TARGETS test_gpu DESTINATION unittest)
+
+endif ()
\ No newline at end of file

core/src/index/unittest/test_idmap.cpp

@@ -21,8 +21,10 @@
 #include "knowhere/adapter/Structure.h"
 #include "knowhere/common/Exception.h"
 #include "knowhere/index/vector_index/IndexIDMAP.h"
+#ifdef MILVUS_GPU_VERSION
+#include "knowhere/index/vector_index/IndexGPUIDMAP.h"
 #include "knowhere/index/vector_index/helpers/Cloner.h"
-
+#endif
 #include "Helper.h"
 #include "unittest/utils.h"
 
@@ -116,6 +118,7 @@ TEST_F(IDMAPTest, idmap_serialize) {
     }
 }
 
+#ifdef MILVUS_GPU_VERSION
 TEST_F(IDMAPTest, copy_test) {
     ASSERT_TRUE(!xb.empty());
 
@@ -175,3 +178,4 @@ TEST_F(IDMAPTest, copy_test) {
         AssertAnns(device_result, nq, k);
     }
 }
+#endif

core/src/index/unittest/test_ivf.cpp

@@ -20,13 +20,24 @@
 #include <iostream>
 #include <thread>
 
+#ifdef MILVUS_GPU_VERSION
 #include <faiss/gpu/GpuIndexIVFFlat.h>
+#endif
 
 #include "knowhere/common/Exception.h"
 #include "knowhere/common/Timer.h"
-#include "knowhere/index/vector_index/IndexGPUIVF.h"
+
 #include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+
+#ifdef MILVUS_GPU_VERSION
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
 #include "knowhere/index/vector_index/helpers/Cloner.h"
+#endif
 
 #include "unittest/Helper.h"
 #include "unittest/utils.h"
@@ -39,8 +50,9 @@ class IVFTest : public DataGen, public TestWithParam<::std::tuple<std::string, P
  protected:
     void
     SetUp() override {
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
-
+#endif
         ParameterType parameter_type;
         std::tie(index_type, parameter_type) = GetParam();
         // Init_with_default();
@@ -54,7 +66,9 @@ class IVFTest : public DataGen, public TestWithParam<::std::tuple<std::string, P
 
     void
     TearDown() override {
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().Free();
+#endif
     }
 
  protected:
@@ -64,15 +78,17 @@ class IVFTest : public DataGen, public TestWithParam<::std::tuple<std::string, P
 };
 
 INSTANTIATE_TEST_CASE_P(IVFParameters, IVFTest,
-                        Values(std::make_tuple("IVF", ParameterType::ivf),
-                               std::make_tuple("GPUIVF", ParameterType::ivf),
-                               std::make_tuple("IVFPQ", ParameterType::ivfpq),
-                               std::make_tuple("GPUIVFPQ", ParameterType::ivfpq),
-                               std::make_tuple("IVFSQ", ParameterType::ivfsq),
+                        Values(
+#ifdef MILVUS_GPU_VERSION
+                            std::make_tuple("GPUIVF", ParameterType::ivf),
+                            std::make_tuple("GPUIVFPQ", ParameterType::ivfpq),
+                            std::make_tuple("GPUIVFSQ", ParameterType::ivfsq),
 #ifdef CUSTOMIZATION
-                               std::make_tuple("IVFSQHybrid", ParameterType::ivfsq),
+                            std::make_tuple("IVFSQHybrid", ParameterType::ivfsq),
+#endif
 #endif
-                               std::make_tuple("GPUIVFSQ", ParameterType::ivfsq)));
+                            std::make_tuple("IVF", ParameterType::ivf), std::make_tuple("IVFPQ", ParameterType::ivfpq),
+                            std::make_tuple("IVFSQ", ParameterType::ivfsq)));
 
 TEST_P(IVFTest, ivf_basic) {
     assert(!xb.empty());
@@ -148,6 +164,7 @@ TEST_P(IVFTest, ivf_serialize) {
     }
 }
 
+#ifdef MILVUS_GPU_VERSION
 TEST_P(IVFTest, clone_test) {
     assert(!xb.empty());
 
@@ -238,7 +255,9 @@ TEST_P(IVFTest, clone_test) {
         }
     }
 }
+#endif
 
+#ifdef MILVUS_GPU_VERSION
 #ifdef CUSTOMIZATION
 TEST_P(IVFTest, gpu_seal_test) {
     std::vector<std::string> support_idx_vec{"GPUIVF", "GPUIVFSQ", "IVFSQHybrid"};
@@ -271,5 +290,5 @@ TEST_P(IVFTest, gpu_seal_test) {
     auto with_seal = tc.RecordSection("With seal");
     ASSERT_GE(without_seal, with_seal);
 }
-
+#endif
 #endif

core/src/index/unittest/test_nsg/CMakeLists.txt

@@ -4,14 +4,13 @@
 
 add_definitions(-std=c++11 -O3 -lboost -march=native -Wall -DINFO)
 
-find_package(OpenMP)
+find_package(OpenMP REQUIRED)
 if (OPENMP_FOUND)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
 else ()
     message(FATAL_ERROR "no OpenMP supprot")
 endif ()
-message(${OpenMP_CXX_FLAGS})
 
 include_directories(${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/nsg)
 aux_source_directory(${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/nsg nsg_src)
@@ -20,9 +19,9 @@ set(interface_src
         ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexNSG.cpp
         )
 
-if(NOT TARGET test_nsg)
+if (NOT TARGET test_nsg)
     add_executable(test_nsg test_nsg.cpp ${interface_src} ${nsg_src} ${util_srcs} ${ivf_srcs})
-endif()
+endif ()
 
 target_link_libraries(test_nsg ${depend_libs} ${unittest_libs} ${basic_libs})
 ##############################

core/src/index/unittest/test_nsg/test_nsg.cpp

@@ -21,7 +21,9 @@
 #include "knowhere/common/Exception.h"
 #include "knowhere/index/vector_index/FaissBaseIndex.h"
 #include "knowhere/index/vector_index/IndexNSG.h"
+#ifdef MILVUS_GPU_VERSION
 #include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#endif
 #include "knowhere/index/vector_index/nsg/NSGIO.h"
 
 #include "unittest/utils.h"
@@ -37,7 +39,9 @@ class NSGInterfaceTest : public DataGen, public ::testing::Test {
     void
     SetUp() override {
         // Init_with_default();
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, 1024 * 1024 * 200, 1024 * 1024 * 600, 2);
+#endif
         Generate(256, 1000000 / 100, 1);
         index_ = std::make_shared<knowhere::NSG>();
 
@@ -60,7 +64,9 @@ class NSGInterfaceTest : public DataGen, public ::testing::Test {
 
     void
     TearDown() override {
+#ifdef MILVUS_GPU_VERSION
         knowhere::FaissGpuResourceMgr::GetInstance().Free();
+#endif
     }
 
  protected:

core/src/main.cpp

@@ -25,7 +25,7 @@
 #include "external/easyloggingpp/easylogging++.h"
 #include "metrics/Metrics.h"
 #include "server/Server.h"
-#include "src/version.h"
+#include "src/config.h"
 #include "utils/CommonUtil.h"
 #include "utils/SignalUtil.h"
 
@@ -52,6 +52,11 @@ print_banner() {
     std::cout << std::endl;
     std::cout << "Welcome to Milvus!" << std::endl;
     std::cout << "Milvus " << BUILD_TYPE << " version: v" << MILVUS_VERSION << ", built at " << BUILD_TIME << std::endl;
+#ifdef MILVUS_CPU_VERSION
+    std::cout << "You are using Milvus CPU version" << std::endl;
+#else
+    std::cout << "You are using Milvus GPU version" << std::endl;
+#endif
     std::cout << std::endl;
 }
 
@@ -95,7 +100,7 @@ main(int argc, char* argv[]) {
                 char* log_filename_ptr = strdup(optarg);
                 log_config_file = log_filename_ptr;
                 free(log_filename_ptr);
-                std::cout << "Initial log config from: " << log_config_file << std::endl;
+                std::cout << "Initializing log config from: " << log_config_file << std::endl;
                 break;
             }
             case 'p': {

core/src/metrics/SystemInfo.cpp

@@ -19,7 +19,6 @@
 #include "utils/Log.h"
 
 #include <dirent.h>
-#include <nvml.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
@@ -29,6 +28,10 @@
 #include <string>
 #include <utility>
 
+#ifdef MILVUS_GPU_VERSION
+#include <nvml.h>
+#endif
+
 namespace milvus {
 namespace server {
 
@@ -60,6 +63,7 @@ SystemInfo::Init() {
     total_ram_ = GetPhysicalMemory();
     fclose(file);
 
+#ifdef MILVUS_GPU_VERSION
     // initialize GPU information
     nvmlReturn_t nvmlresult;
     nvmlresult = nvmlInit();
@@ -72,6 +76,7 @@ SystemInfo::Init() {
         SERVER_LOG_ERROR << "Unable to get devidce number";
         return;
     }
+#endif
 
     // initialize network traffic information
     std::pair<uint64_t, uint64_t> in_and_out_octets = Octets();
@@ -213,6 +218,9 @@ SystemInfo::GPUMemoryTotal() {
     if (!initialized_)
         Init();
     std::vector<uint64_t> result;
+
+#ifdef MILVUS_GPU_VERSION
+
     nvmlMemory_t nvmlMemory;
     for (int i = 0; i < num_device_; ++i) {
         nvmlDevice_t device;
@@ -220,6 +228,8 @@ SystemInfo::GPUMemoryTotal() {
         nvmlDeviceGetMemoryInfo(device, &nvmlMemory);
         result.push_back(nvmlMemory.total);
     }
+#endif
+
     return result;
 }
 
@@ -228,6 +238,9 @@ SystemInfo::GPUTemperature() {
     if (!initialized_)
         Init();
     std::vector<uint64_t> result;
+
+#ifdef MILVUS_GPU_VERSION
+
     for (int i = 0; i < num_device_; i++) {
         nvmlDevice_t device;
         nvmlDeviceGetHandleByIndex(i, &device);
@@ -235,6 +248,9 @@ SystemInfo::GPUTemperature() {
         nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp);
         result.push_back(temp);
     }
+
+#endif
+
     return result;
 }
 
@@ -283,6 +299,9 @@ SystemInfo::GPUMemoryUsed() {
         Init();
 
     std::vector<uint64_t> result;
+
+#ifdef MILVUS_GPU_VERSION
+
     nvmlMemory_t nvmlMemory;
     for (int i = 0; i < num_device_; ++i) {
         nvmlDevice_t device;
@@ -290,6 +309,9 @@ SystemInfo::GPUMemoryUsed() {
         nvmlDeviceGetMemoryInfo(device, &nvmlMemory);
         result.push_back(nvmlMemory.used);
     }
+
+#endif
+
     return result;
 }
 

core/src/scheduler/JobMgr.cpp

@@ -104,25 +104,20 @@ JobMgr::build_task(const JobPtr& job) {
 
 void
 JobMgr::calculate_path(const TaskPtr& task) {
-    if (task->type_ == TaskType::SearchTask) {
-        if (task->label()->Type() != TaskLabelType::SPECIFIED_RESOURCE) {
-            return;
-        }
+    if (task->type_ != TaskType::SearchTask) {
+        return;
+    }
 
-        std::vector<std::string> path;
-        auto spec_label = std::static_pointer_cast<SpecResLabel>(task->label());
-        auto src = res_mgr_->GetDiskResources()[0];
-        auto dest = spec_label->resource();
-        ShortestPath(src.lock(), dest.lock(), res_mgr_, path);
-        task->path() = Path(path, path.size() - 1);
-    } else if (task->type_ == TaskType::BuildIndexTask) {
-        auto spec_label = std::static_pointer_cast<SpecResLabel>(task->label());
-        auto src = res_mgr_->GetDiskResources()[0];
-        auto dest = spec_label->resource();
-        std::vector<std::string> path;
-        ShortestPath(src.lock(), dest.lock(), res_mgr_, path);
-        task->path() = Path(path, path.size() - 1);
+    if (task->label()->Type() != TaskLabelType::SPECIFIED_RESOURCE) {
+        return;
     }
+
+    std::vector<std::string> path;
+    auto spec_label = std::static_pointer_cast<SpecResLabel>(task->label());
+    auto src = res_mgr_->GetDiskResources()[0];
+    auto dest = spec_label->resource();
+    ShortestPath(src.lock(), dest.lock(), res_mgr_, path);
+    task->path() = Path(path, path.size() - 1);
 }
 
 }  // namespace scheduler

core/src/scheduler/SchedInst.cpp

@@ -18,7 +18,6 @@
 #include "scheduler/SchedInst.h"
 #include "ResourceFactory.h"
 #include "Utils.h"
-#include "knowhere/index/vector_index/IndexGPUIVF.h"
 #include "server/Config.h"
 
 #include <set>
@@ -55,8 +54,8 @@ load_simple_config() {
     // get resources
     auto gpu_ids = get_gpu_pool();
 
-    int32_t index_build_device_id;
-    config.GetResourceConfigIndexBuildDevice(index_build_device_id);
+    int32_t build_gpu_id;
+    config.GetResourceConfigIndexBuildDevice(build_gpu_id);
 
     // create and connect
     ResMgrInst::GetInstance()->Add(ResourceFactory::Create("disk", "DISK", 0, true, false));
@@ -70,15 +69,15 @@ load_simple_config() {
     for (auto& gpu_id : gpu_ids) {
         ResMgrInst::GetInstance()->Add(ResourceFactory::Create(std::to_string(gpu_id), "GPU", gpu_id, true, true));
         ResMgrInst::GetInstance()->Connect("cpu", std::to_string(gpu_id), pcie);
-        if (index_build_device_id == gpu_id) {
+        if (build_gpu_id == gpu_id) {
             find_build_gpu_id = true;
         }
     }
 
-    if (not find_build_gpu_id && index_build_device_id != server::CPU_DEVICE_ID) {
+    if (not find_build_gpu_id) {
         ResMgrInst::GetInstance()->Add(
-            ResourceFactory::Create(std::to_string(index_build_device_id), "GPU", index_build_device_id, true, true));
-        ResMgrInst::GetInstance()->Connect("cpu", std::to_string(index_build_device_id), pcie);
+            ResourceFactory::Create(std::to_string(build_gpu_id), "GPU", build_gpu_id, true, true));
+        ResMgrInst::GetInstance()->Connect("cpu", std::to_string(build_gpu_id), pcie);
     }
 }
 

core/src/scheduler/SchedInst.h

@@ -106,6 +106,7 @@ class OptimizerInst {
                         has_cpu = true;
                     }
                 }
+
                 std::vector<PassPtr> pass_list;
                 pass_list.push_back(std::make_shared<LargeSQ8HPass>());
                 pass_list.push_back(std::make_shared<HybridPass>());

core/src/scheduler/TaskCreator.cpp

@@ -70,15 +70,8 @@ TaskCreator::Create(const DeleteJobPtr& job) {
 std::vector<TaskPtr>
 TaskCreator::Create(const BuildIndexJobPtr& job) {
     std::vector<TaskPtr> tasks;
-    server::Config& config = server::Config::GetInstance();
-    int32_t build_index_id;
-    Status stat = config.GetResourceConfigIndexBuildDevice(build_index_id);
-    ResourcePtr res_ptr;
-    if (build_index_id == server::CPU_DEVICE_ID) {
-        res_ptr = ResMgrInst::GetInstance()->GetResource("cpu");
-    } else {
-        res_ptr = ResMgrInst::GetInstance()->GetResource(ResourceType::GPU, build_index_id);
-    }
+    // TODO(yukun): remove "disk" hardcode here
+    ResourcePtr res_ptr = ResMgrInst::GetInstance()->GetResource("disk");
 
     for (auto& to_index_file : job->to_index_files()) {
         auto label = std::make_shared<SpecResLabel>(std::weak_ptr<Resource>(res_ptr));

core/src/scheduler/Utils.cpp

@@ -19,7 +19,9 @@
 #include "server/Config.h"
 #include "utils/Log.h"
 
+#ifdef MILVUS_GPU_VERSION
 #include <cuda_runtime.h>
+#endif
 #include <chrono>
 #include <set>
 #include <string>
@@ -38,7 +40,9 @@ get_current_timestamp() {
 uint64_t
 get_num_gpu() {
     int n_devices = 0;
+#ifdef MILVUS_GPU_VERSION
     cudaGetDeviceCount(&n_devices);
+#endif
     return n_devices;
 }
 

core/src/scheduler/job/BuildIndexJob.cpp

@@ -50,10 +50,7 @@ void
 BuildIndexJob::BuildIndexDone(size_t to_index_id) {
     std::unique_lock<std::mutex> lock(mutex_);
     to_index_files_.erase(to_index_id);
-    if (to_index_files_.empty()) {
-        cv_.notify_all();
-    }
-
+    cv_.notify_all();
     SERVER_LOG_DEBUG << "BuildIndexJob " << id() << " finish index file: " << to_index_id;
 }
 

core/src/scheduler/job/SearchJob.cpp

@@ -49,21 +49,13 @@ void
 SearchJob::SearchDone(size_t index_id) {
     std::unique_lock<std::mutex> lock(mutex_);
     index_files_.erase(index_id);
-    if (index_files_.empty()) {
-        cv_.notify_all();
-    }
-
+    cv_.notify_all();
     SERVER_LOG_DEBUG << "SearchJob " << id() << " finish index file: " << index_id;
 }
 
-ResultIds&
-SearchJob::GetResultIds() {
-    return result_ids_;
-}
-
-ResultDistances&
-SearchJob::GetResultDistances() {
-    return result_distances_;
+ResultSet&
+SearchJob::GetResult() {
+    return result_;
 }
 
 Status&

core/src/scheduler/job/SearchJob.h

@@ -29,7 +29,6 @@
 #include <vector>
 
 #include "Job.h"
-#include "db/Types.h"
 #include "db/meta/MetaTypes.h"
 
 namespace milvus {
@@ -38,9 +37,9 @@ namespace scheduler {
 using engine::meta::TableFileSchemaPtr;
 
 using Id2IndexMap = std::unordered_map<size_t, TableFileSchemaPtr>;
-
-using ResultIds = engine::ResultIds;
-using ResultDistances = engine::ResultDistances;
+using IdDistPair = std::pair<int64_t, double>;
+using Id2DistVec = std::vector<IdDistPair>;
+using ResultSet = std::vector<Id2DistVec>;
 
 class SearchJob : public Job {
  public:
@@ -56,11 +55,8 @@ class SearchJob : public Job {
     void
     SearchDone(size_t index_id);
 
-    ResultIds&
-    GetResultIds();
-
-    ResultDistances&
-    GetResultDistances();
+    ResultSet&
+    GetResult();
 
     Status&
     GetStatus();
@@ -94,11 +90,6 @@ class SearchJob : public Job {
         return index_files_;
     }
 
-    std::mutex&
-    mutex() {
-        return mutex_;
-    }
-
  private:
     uint64_t topk_ = 0;
     uint64_t nq_ = 0;
@@ -108,8 +99,7 @@ class SearchJob : public Job {
 
     Id2IndexMap index_files_;
     // TODO: column-base better ?
-    ResultIds result_ids_;
-    ResultDistances result_distances_;
+    ResultSet result_;
     Status status_;
 
     std::mutex mutex_;

core/src/scheduler/optimizer/OnlyGPUPass.cpp

@@ -46,7 +46,7 @@ OnlyGPUPass::Run(const TaskPtr& task) {
     auto label = std::make_shared<SpecResLabel>(std::weak_ptr<Resource>(res_ptr));
     task->label() = label;
 
-    specified_gpu_id_ = (specified_gpu_id_ + 1) % gpu_id.size();
+    specified_gpu_id_ = specified_gpu_id_++ % gpu_id.size();
     return true;
 }