Merge pull request #323 from milvus-io/0.5.3

Merge from 0.5.3

CHANGELOG.md

 # Changelog
 
 Please mark all change in change log and use the ticket from JIRA.
+# Milvus 0.5.3 (TODO)
+
+## Bug
+- \#258 - Bytes type in proto cause big-endian/little-endian problem
+
+## Feature
+
+## Improvement
+- \#204 - improve grpc performance in search
+- \#207 - Add more unittest for config set/get
+- \#208 - optimize unittest to support run single test more easily
+- \#284 - Change C++ SDK to shared library
+- \#260 - C++ SDK README
+
+## Task
 
 # Milvus 0.5.2 (2019-11-07)
 
@@ -10,7 +25,7 @@ Please mark all change in change log and use the ticket from JIRA.
 ## Feature
 
 ## Improvement
-- \#190 - Update default config:use_blas_threshold to 1100 and server version printout to 0.52
+- \#190 - Update default config:use_blas_threshold to 1100 and server version printout to 0.5.2
 
 ## Task
 

README.md

@@ -8,7 +8,7 @@
 ![Release](https://img.shields.io/badge/release-v0.5.2-yellowgreen)
 ![Release_date](https://img.shields.io/badge/release%20date-November-yellowgreen)
 
-[中文版](README_CN.md) 
+[中文版](README_CN.md) | [日本語版](README_JP.md)
 
 ## What is Milvus
 
@@ -16,7 +16,7 @@ Milvus is the world's fastest similarity search engine for massive-scale feature
 
 For more detailed introduction of Milvus and its architecture, see [Milvus overview](https://www.milvus.io/docs/en/aboutmilvus/overview/).
 
-Milvus provides stable [Python](https://github.com/milvus-io/pymilvus), [Java](https://github.com/milvus-io/milvus-sdk-java) and C++ APIs. 
+Milvus provides stable [Python](https://github.com/milvus-io/pymilvus), [Java](https://github.com/milvus-io/milvus-sdk-java) and [C++](https://github.com/milvus-io/milvus/tree/master/core/src/sdk) APIs. 
 
 Keep up-to-date with newest releases and latest updates by reading Milvus [release notes](https://www.milvus.io/docs/en/release/v0.5.2/).
 

README_JP.md

@@ -13,142 +13,24 @@
 
 ## 概要
 
-Milvus は大規模な特徴ベクトルにむかう類似性検索エンジンです。不均質な計算アーキテクチャーに基づいて効率を最大化出来ます。数十億のベクタの中に目標を検索できるまで数ミリ秒しかかからず、最低限の計算資源だけが必要です。
+Milvusは世界中一番早い特徴ベクトルにむかう類似性検索エンジンです。不均質な計算アーキテクチャーに基づいて効率を最大化出来ます。数十億のベクタの中に目標を検索できるまで数ミリ秒しかかからず、最低限の計算資源だけが必要です。
 
-Milvus は安定的な Python、Java 又は C++ APIsを提供します。
+Milvusは安定的なPython、Java又は C++ APIsを提供します。
 
 Milvus [リリースノート](https://milvus.io/docs/en/release/v0.5.2/)を読んで最新バージョンや更新情報を手に入れます。
 
-- 不均質な計算アーキテクチャー
-
-  Milvusは不均質な計算アーキテクチャーに基づいて効率を最大化出来ます。
-
-- 様々な索引方法
-
-  Milvusはさまざまな索引方法を支えます。量子化、 木、 グラフに基づいて索引を作成できます。
-
-- 知能てきな資源管理
-
-  Milvusはデータセットと利用できる資源を基づいて、自動的に検索アルゴリズムと索引作成方法を選びます。
-
-- 水平拡張
-
-  Milvusはオンラインとオフラインに記憶域と計算を簡単な命令で拡張できます。
-
-- 高い可用性
-
-  MilvusはKubernetes枠組みと統合するので、 単一障害点を避けられます。
-
-- 高い互換性
-
-  Milvusはほぼ全ての深層学習モデルと主要なプログラミング言語と互換性があります。
-
-- やすい使い方
-
-  Milvusは簡単にインストールできます。ベクタ以外のことを心配する必要がありますん。
-
-- 視覚化てきな監視モード
-
-  Prometheusに基づいてGUIでシステムの性能を監視出来ます。
-
-## アーキテクチャー
-
-![Milvus_arch](https://github.com/milvus-io/docs/blob/master/assets/milvus_arch.png)
 
 ## はじめに
 
-### ハードウェア要件
+DockerでMilvusをインストールすることは簡単です。[Milvusインストール案内](https://milvus.io/docs/en/userguide/install_milvus/) を参考してください。ソースからMilvusを構築するために、[ソースから構築する](install.md)を参考してください。
 
-| コンポーネント | お勧めの配置           |
-| --------- | ----------------------------------- |
-| CPU       | Intel CPU Haswell 以上      |
-| GPU       | NVIDIA Pascal series 以上   |
-| RAM メモリ   | 8 GB 以上 (データ規模に関わる) |
-| ハードディスク   | SATA 3.0 SSD 以上           |
+Milvusをコンフィグするために、[Milvusコンフィグ](https://github.com/milvus-io/docs/blob/master/reference/milvus_config.md)を読んでください。
 
-### Dockerでインストールする
+### 初めてのMilvusプログラムを試す
 
-DockerでMilvusをインストールすることは簡単です。 [Milvusインストール案内](https://milvus.io/docs/en/userguide/install_milvus/) を参考してください。
+[Python](https://www.milvus.io/docs/en/userguide/example_code/)や[Java](https://github.com/milvus-io/milvus-sdk-java/tree/master/examples)などのサンプルコードを使ってMilvusプログラムを試す。
 
-### ソースから構築する
-
-#### ソフトウェア要件
-
-- Ubuntu 18.04 以上
-- CMake 3.14 以上
-- CUDA 10.0 以上
-- NVIDIA driver 418 以上
-
-#### コンパイル
-
-##### 1  依存コンポーネントをインストールする
-
-```shell
-$ cd [Milvus sourcecode path]/core
-./ubuntu_build_deps.sh
-```
-
-##### 2 構築する
-
-```shell
-$ cd [Milvus sourcecode path]/core
-$ ./build.sh -t Debug
-or 
-$ ./build.sh -t Release
-```
-
-構築が完成するとき、 Milvusを実行するために必要なものは全てこのディレクトリにあります： `[Milvus root path]/core/milvus`。
-
-#### Milvusサーバーを実行する
-
-```shell
-$ cd [Milvus root path]/core/milvus
-```
-
-`lib/`　ディレクトリを　`LD_LIBRARY_PATH`　に添付する。
-
-```shell
-$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/milvus/lib
-```
-
-Milvusサーバーを実行する。
-
-```shell
-$ cd scripts
-$ ./start_server.sh
-```
-
-Milvusサーバーを止めるために、次のコードを実行する：
-
-```shell
-$ ./stop_server.sh
-```
-
-`conf/server_config.yaml` と `conf/log_config.conf` でMilvusをコンフィグするために、 [Milvusコンフィグ](https://github.com/milvus-io/docs/blob/master/reference/milvus_config.md)を読んでください。
-
-### 初めてのMilvusプログラムを実行する
-
-#### Pythonサンプルコードを実行する
-
-[Python 3.5](https://www.python.org/downloads/)以上のバージョンがインストールされていることを確かめてください。
-
-Milvus Python SDK　をインストールする。
-
-```shell
-# Install Milvus Python SDK
-$ pip install pymilvus==0.2.3
-```
-
-新しいファイル　`example.py`　を作成し、 [Pythonサンプルコード]( https://github.com/milvus-io/pymilvus/blob/master/examples/advanced_example.py)を添付してください。
-
-サンプルコードを実行する。
-
-```shell
-# Run Milvus Python example
-$ python3 example.py
-```
-
-#### C++サンプルコードを実行する
+C++サンプルコードを実行するために、次のコマンドをつかってください。
 
 ```shell
  # Run Milvus C++ example
@@ -156,11 +38,9 @@ $ python3 example.py
  $ ./sdk_simple
 ```
 
-#### Javaサンプルコードを実行する
-
-Java 8以上のバージョンがインストールされていることを確かめてください。
+## Milvusロードマップ
 
-[このリンク](https://github.com/milvus-io/milvus-sdk-java/tree/master/examples)でサンプルコードを手に入れます。
+[ロードマップ](https://milvus.io/docs/en/roadmap/)を読んで、追加する予定の特性が分かります。
 
 ## 貢献規約
 
@@ -172,23 +52,20 @@ Java 8以上のバージョンがインストールされていることを確
 
 他の貢献者と交流したい場合は、Milvusの [slackチャンネル](https://join.slack.com/t/milvusio/shared_invite/enQtNzY1OTQ0NDI3NjMzLWNmYmM1NmNjOTQ5MGI5NDhhYmRhMGU5M2NhNzhhMDMzY2MzNDdlYjM5ODQ5MmE3ODFlYzU3YjJkNmVlNDQ2ZTk)に参加してください。
 
-## Milvusロードマップ
-
-[ロードマップ](https://milvus.io/docs/en/roadmap/)を読んで、追加する予定の特性が分かります。
 
 ## 参考情報
 
-[Milvus公式サイト](https://www.milvus.io)
+- [Milvus.io](https://www.milvus.io)
 
-[Milvusドキュメント](https://www.milvus.io/docs/en/userguide/install_milvus/)
+- [Milvus](https://github.com/milvus-io/bootcamp)
 
-[Milvusトレーニングセンター](https://github.com/milvus-io/bootcamp)
+- [Milvus Medium](https://medium.com/@milvusio)
 
-[Milvusブロック](https://www.milvus.io/blog/)
+- [Milvus CSDN](https://zilliz.blog.csdn.net/)
 
-[Milvus CSDN](https://zilliz.blog.csdn.net/)
+- [Milvus ツイッター](https://twitter.com/milvusio)
 
-[Milvusロードマップ](https://milvus.io/docs/en/roadmap/)
+- [Milvus Facebook](https://www.facebook.com/io.milvus.5)
 
 
 ## ライセンス

ci/jenkins/Jenkinsfile

@@ -75,7 +75,7 @@ pipeline {
                             steps {
                                 container('milvus-build-env') {
                                     script {
-                                        load "${env.WORKSPACE}/ci/jenkins/step/package.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkins/step/packaging.groovy"
                                     }
                                 }
                             }

ci/jenkins/scripts/packaging.sh

+#!/usr/bin/env bash
+
+set -ex
+
+pip3 install -r requirements.txt
+./yaml_processor.py merge -f /opt/milvus/conf/server_config.yaml -m ../yaml/update_server_config.yaml -i && \
+rm /opt/milvus/conf/server_config.yaml.bak
+
+if [ -d "/opt/milvus/unittest" ]; then
+  rm -rf "/opt/milvus/unittest"
+fi
+
+tar -zcvf ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz -C /opt/ milvus
\ No newline at end of file

ci/jenkins/step/deploySingle2Dev.groovy

 sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
 sh 'helm repo update'
 dir ('milvus-helm') {
-    checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+    checkout([$class: 'GitSCM', branches: [[name: "0.5.3"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.3:refs/remotes/origin/0.5.3"]]])
     dir ("milvus-gpu") {
         sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu -f ci/db_backend/sqlite_values.yaml -f ci/filebeat/values.yaml --namespace milvus ."
     }

ci/jenkins/step/package.groovy

-timeout(time: 5, unit: 'MINUTES') {
-    dir ("ci/jenkins/scripts") {
-        sh "pip3 install -r requirements.txt"
-        sh "./yaml_processor.py merge -f /opt/milvus/conf/server_config.yaml -m ../yaml/update_server_config.yaml -i && rm /opt/milvus/conf/server_config.yaml.bak"
-    }
-    sh "tar -zcvf ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz -C /opt/ milvus"
-    withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
-        def uploadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -T ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz")
-        if (uploadStatus != 0) {
-            error("\" ${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" upload to \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" failed!")
-        }
-    }
-}

ci/jenkins/step/packaging.groovy

+timeout(time: 5, unit: 'MINUTES') {
+    dir ("ci/jenkins/scripts") {
+        sh "./packaging.sh"
+        withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
+            def uploadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -T ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz")
+            if (uploadStatus != 0) {
+                error("\" ${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" upload to \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" failed!")
+            }
+        }
+    }
+}

ci/jenkins/step/singleDevNightlyTest.groovy

@@ -8,7 +8,7 @@ timeout(time: 90, unit: 'MINUTES') {
 
     if (!fileExists('milvus-helm')) {
         dir ("milvus-helm") {
-            checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+            checkout([$class: 'GitSCM', branches: [[name: "0.5.3"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.3:refs/remotes/origin/0.5.3"]]])
         }
     }
     dir ("milvus-helm") {

ci/jenkins/step/singleDevTest.groovy

@@ -10,7 +10,7 @@ timeout(time: 60, unit: 'MINUTES') {
 
     // if (!fileExists('milvus-helm')) {
     //     dir ("milvus-helm") {
-    //         checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+    //         checkout([$class: 'GitSCM', branches: [[name: "0.5.3"]], userRemoteConfigs: [[url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.3:refs/remotes/origin/0.5.3"]]])
     //     }
     // }
     // dir ("milvus-helm") {

ci/jenkinsfile/packaged_milvus.groovy

@@ -5,6 +5,9 @@ container('milvus-build-env') {
                 gitlabCommitStatus(name: 'Packaged Engine') {
                     if (fileExists('milvus')) {
                         try {
+                            if (fileExists('milvus/unittest')) {
+                                sh "rm -rf ./milvus/unittest"
+                            }
                             sh "tar -zcvf ./${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz ./milvus"
                             def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
                             fileTransfer.FileTransfer("${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz", "${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}", 'nas storage')

core/CMakeLists.txt

@@ -71,7 +71,7 @@ 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.2")
+    set(MILVUS_VERSION "0.5.3")
 endif()
 
 message(STATUS "Build version = ${MILVUS_VERSION}")

core/src/grpc/README.md

+We manually change two APIs in "milvus.pd.h":
+    add_vector_data()
+    add_row_id_array()
+    add_ids()
+    add_distances()
+If proto files need be generated again, remember to re-change above APIs.
\ No newline at end of file

core/src/grpc/gen-milvus/milvus.grpc.pb.cc

@@ -201,60 +201,60 @@ void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* cont
   return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::VectorIds>::Create(channel_.get(), cq, rpcmethod_Insert_, context, request, false);
 }
 
-::grpc::Status MilvusService::Stub::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Stub::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResult* response) {
   return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Search_, context, request, response);
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
 }
 
-void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, true);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, true);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, false);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, false);
 }
 
-::grpc::Status MilvusService::Stub::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Stub::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResult* response) {
   return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_SearchInFiles_, context, request, response);
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, std::function<void(::grpc::Status)> f) {
   ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
 }
 
-void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResult* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
   ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, true);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, true);
 }
 
-::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
-  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, false);
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResult>* MilvusService::Stub::PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResult>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, false);
 }
 
 ::grpc::Status MilvusService::Stub::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) {
@@ -510,12 +510,12 @@ MilvusService::Service::Service() {
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[5],
       ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResult>(
           std::mem_fn(&MilvusService::Service::Search), this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[6],
       ::grpc::internal::RpcMethod::NORMAL_RPC,
-      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResult>(
           std::mem_fn(&MilvusService::Service::SearchInFiles), this)));
   AddMethod(new ::grpc::internal::RpcServiceMethod(
       MilvusService_method_names[7],
@@ -597,14 +597,14 @@ MilvusService::Service::~Service() {
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status MilvusService::Service::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Service::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResult* response) {
   (void) context;
   (void) request;
   (void) response;
   return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
 }
 
-::grpc::Status MilvusService::Service::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+::grpc::Status MilvusService::Service::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResult* response) {
   (void) context;
   (void) request;
   (void) response;

core/src/grpc/milvus.proto

@@ -84,24 +84,11 @@ message SearchInFilesParam {
 /**
  * @brief Query result params
  */
-message QueryResult {
-    int64 id = 1;
-    double distance = 2;
-}
-
-/**
- * @brief TopK query result
- */
 message TopKQueryResult {
-    repeated QueryResult query_result_arrays = 1;
-}
-
-/**
- * @brief List of topK query result
- */
-message TopKQueryResultList {
     Status status = 1;
-    repeated TopKQueryResult topk_query_result = 2;
+    int64 row_num = 2;
+    repeated int64 ids = 3;
+    repeated float distances = 4;
 }
 
 /**
@@ -227,7 +214,7 @@ service MilvusService {
      *
      * @return query result array.
      */
-    rpc Search(SearchParam) returns (TopKQueryResultList) {}
+    rpc Search(SearchParam) returns (TopKQueryResult) {}
 
     /**
      * @brief Internal use query interface
@@ -241,7 +228,7 @@ service MilvusService {
      *
      * @return query result array.
      */
-    rpc SearchInFiles(SearchInFilesParam) returns (TopKQueryResultList) {}
+    rpc SearchInFiles(SearchInFilesParam) returns (TopKQueryResult) {}
 
     /**
      * @brief Get table schema

core/src/index/cmake/ThirdPartyPackagesCore.cmake

@@ -247,7 +247,8 @@ if(CUSTOMIZATION)
         # set(FAISS_MD5 "87fdd86351ffcaf3f80dc26ade63c44b") # commit-id 841a156e67e8e22cd8088e1b58c00afbf2efc30b branch-0.2.1
         # set(FAISS_MD5 "f3b2ce3364c3fa7febd3aa7fdd0fe380") # commit-id 694e03458e6b69ce8a62502f71f69a614af5af8f branch-0.3.0
         # set(FAISS_MD5 "bb30722c22390ce5f6759ccb216c1b2a") # commit-id d324db297475286afe107847c7fb7a0f9dc7e90e branch-0.3.0
-        set(FAISS_MD5 "2293cdb209c3718e3b19f3edae8b32b3") # commit-id a13c1205dc52977a9ad3b33a14efa958604a8bff branch-0.3.0
+	# set(FAISS_MD5 "2293cdb209c3718e3b19f3edae8b32b3") # commit-id a13c1205dc52977a9ad3b33a14efa958604a8bff branch-0.3.0
+	set(FAISS_MD5 "3632192f06b70e5f3fac8e2f08ced503") # commit-id fbd5b7566466c5665bb646f2b2f911c8544090f5 branch-0.3.0
     endif()
 else()
     set(FAISS_SOURCE_URL "https://github.com/JinHai-CN/faiss/archive/1.6.0.tar.gz")

core/src/index/unittest/faiss_benchmark/faiss_benchmark_test.cpp

@@ -202,14 +202,14 @@ parse_ann_test_name(const std::string& ann_test_name, size_t& dim, faiss::Metric
 int32_t
 GetResultHitCount(const faiss::Index::idx_t* ground_index, const faiss::Index::idx_t* index, size_t ground_k, size_t k,
                   size_t nq, int32_t index_add_loops) {
-    assert(ground_k <= k);
+    size_t min_k = std::min(ground_k, k);
     int hit = 0;
     for (int i = 0; i < nq; i++) {
         // count the num of results exist in ground truth result set
         // each result replicates INDEX_ADD_LOOPS times
         for (int j_c = 0; j_c < k; j_c++) {
             int r_c = index[i * k + j_c];
-            for (int j_g = 0; j_g < ground_k / index_add_loops; j_g++) {
+            for (int j_g = 0; j_g < min_k / index_add_loops; j_g++) {
                 if (ground_index[i * ground_k + j_g] == r_c) {
                     hit++;
                     continue;
@@ -283,7 +283,11 @@ load_base_data(faiss::Index*& index, const std::string& ann_test_name, const std
         // add index multiple times to get ~1G data set
         for (int i = 0; i < index_add_loops; i++) {
             printf("[%.3f s] No.%d Indexing database, size %ld*%ld\n", elapsed() - t0, i, nb, d);
-            gpu_index->add(nb, xb);
+            std::vector<faiss::Index::idx_t> xids(nb);
+            for (int t = 0; t < nb; t++) {
+                xids[t] = i * nb + t;
+            }
+            gpu_index->add_with_ids(nb, xb, xids.data());
         }
 
         printf("[%.3f s] Coping GPU index to CPU\n", elapsed() - t0);
@@ -359,13 +363,14 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
                   const int32_t search_loops) {
     double t0 = elapsed();
 
-    const size_t NQ = 1000, NQ_START = 10, NQ_STEP = 10;
-    const size_t K = 1000, K_START = 100, K_STEP = 10;
+    const std::vector<size_t> NQ = {10, 100};
+    const std::vector<size_t> K = {10, 100, 1000};
     const size_t GK = 100;  // topk of ground truth
 
     std::unordered_map<size_t, std::string> mode_str_map = {
         {MODE_CPU, "MODE_CPU"}, {MODE_MIX, "MODE_MIX"}, {MODE_GPU, "MODE_GPU"}};
 
+    double copy_time = 0.0;
     faiss::Index *gpu_index, *index;
     if (query_mode != MODE_CPU) {
         faiss::gpu::GpuClonerOptions option;
@@ -375,7 +380,6 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
         index_composition.index = cpu_index;
         index_composition.quantizer = nullptr;
 
-        double copy_time;
         switch (query_mode) {
             case MODE_MIX: {
                 index_composition.mode = 1;  // 0: all data, 1: copy quantizer, 2: copy data
@@ -420,34 +424,39 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
     }
 
     for (auto nprobe : nprobes) {
-        switch (query_mode) {
-            case MODE_CPU:
-            case MODE_MIX: {
-                faiss::ParameterSpace params;
-                std::string nprobe_str = "nprobe=" + std::to_string(nprobe);
-                params.set_index_parameters(index, nprobe_str.c_str());
-                break;
-            }
-            case MODE_GPU: {
-                faiss::gpu::GpuIndexIVF* gpu_index_ivf = dynamic_cast<faiss::gpu::GpuIndexIVF*>(index);
-                gpu_index_ivf->setNumProbes(nprobe);
+        // brute-force need not set nprobe
+        if (index_key.find("IDMap") == std::string::npos) {
+            switch (query_mode) {
+                case MODE_CPU:
+                case MODE_MIX: {
+                    faiss::ParameterSpace params;
+                    std::string nprobe_str = "nprobe=" + std::to_string(nprobe);
+                    params.set_index_parameters(index, nprobe_str.c_str());
+                    break;
+                }
+                case MODE_GPU: {
+                    faiss::gpu::GpuIndexIVF* gpu_index_ivf = dynamic_cast<faiss::gpu::GpuIndexIVF*>(index);
+                    gpu_index_ivf->setNumProbes(nprobe);
+                }
             }
         }
 
         // output buffers
-        faiss::Index::idx_t* I = new faiss::Index::idx_t[NQ * K];
-        faiss::Index::distance_t* D = new faiss::Index::distance_t[NQ * K];
+        faiss::Index::idx_t* I = new faiss::Index::idx_t[NQ.back() * K.back()];
+        faiss::Index::distance_t* D = new faiss::Index::distance_t[NQ.back() * K.back()];
 
         printf("\n%s | %s - %s | nprobe=%lu\n", ann_test_name.c_str(), index_key.c_str(),
                mode_str_map[query_mode].c_str(), nprobe);
         printf("======================================================================================\n");
-        for (size_t t_nq = NQ_START; t_nq <= NQ; t_nq *= NQ_STEP) {  // nq = {10, 100, 1000}
-            for (size_t t_k = K_START; t_k <= K; t_k *= K_STEP) {    //  k = {100, 1000}
+        for (size_t j = 0; j < K.size(); j++) {
+            size_t t_k = K[j];
+            for (size_t i = 0; i < NQ.size(); i++) {
+                size_t t_nq = NQ[i];
                 faiss::indexIVF_stats.quantization_time = 0.0;
                 faiss::indexIVF_stats.search_time = 0.0;
 
                 double t_start = elapsed(), t_end;
-                for (int i = 0; i < search_loops; i++) {
+                for (int s = 0; s < search_loops; s++) {
                     index->search(t_nq, xq, t_k, D, I);
                 }
                 t_end = elapsed();
@@ -466,7 +475,7 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
                 printf("nq = %4ld, k = %4ld, elapse = %.4fs (quant = %.4fs, search = %.4fs), R@ = %.4f\n", t_nq, t_k,
                        (t_end - t_start) / search_loops, faiss::indexIVF_stats.quantization_time / 1000 / search_loops,
                        faiss::indexIVF_stats.search_time / 1000 / search_loops,
-                       (hit / float(t_nq * GK / index_add_loops)));
+                       (hit / float(t_nq * std::min(GK, t_k) / index_add_loops)));
             }
         }
         printf("======================================================================================\n");
@@ -479,8 +488,9 @@ test_with_nprobes(const std::string& ann_test_name, const std::string& index_key
 }
 
 void
-test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, const QueryMode query_mode,
-              int32_t index_add_loops, const std::vector<size_t>& nprobes, int32_t search_loops) {
+test_ann_hdf5(const std::string& ann_test_name, const std::string& cluster_type, const std::string& index_type,
+              const QueryMode query_mode, int32_t index_add_loops, const std::vector<size_t>& nprobes,
+              int32_t search_loops) {
     double t0 = elapsed();
 
     faiss::gpu::StandardGpuResources res;
@@ -493,7 +503,7 @@ test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, c
         return;
     }
 
-    std::string index_key = "IVF16384," + index_type;
+    std::string index_key = cluster_type + "," + index_type;
 
     if (!parse_ann_test_name(ann_test_name, dim, metric_type)) {
         printf("Invalid ann test name: %s\n", ann_test_name.c_str());
@@ -526,7 +536,7 @@ test_ann_hdf5(const std::string& ann_test_name, const std::string& index_type, c
  *
  * Dataset 	Dimensions 	Train_size 	Test_size 	Neighbors 	Distance 	Download
  * Fashion-
- *  MNIST   784         60,000      10,000 	    100         Euclidean   HDF5 (217MB)
+    MNIST   784         60,000      10,000 	    100         Euclidean   HDF5 (217MB)
  * GIST     960         1,000,000   1,000       100         Euclidean   HDF5 (3.6GB)
  * GloVe    100         1,183,514   10,000      100         Angular     HDF5 (463MB)
  * GloVe    200         1,183,514   10,000      100         Angular     HDF5 (918MB)
@@ -542,30 +552,39 @@ TEST(FAISSTEST, BENCHMARK) {
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     const int32_t SIFT_INSERT_LOOPS = 2;  // insert twice to get ~1G data set
 
-    test_ann_hdf5("sift-128-euclidean", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IDMap", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IDMap", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "Flat", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "Flat", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
-    test_ann_hdf5("sift-128-euclidean", "SQ8", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
 #ifdef CUSTOMIZATION
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_MIX, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("sift-128-euclidean", "SQ8Hybrid", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_CPU, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_MIX, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("sift-128-euclidean", "IVF16384", "SQ8Hybrid", MODE_GPU, SIFT_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
 #endif
 
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     const int32_t GLOVE_INSERT_LOOPS = 1;
 
-    test_ann_hdf5("glove-200-angular", "Flat", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "Flat", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "Flat", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "Flat", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
-    test_ann_hdf5("glove-200-angular", "SQ8", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
 
 #ifdef CUSTOMIZATION
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_MIX, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
-    test_ann_hdf5("glove-200-angular", "SQ8Hybrid", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes, SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_CPU, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_MIX, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
+    test_ann_hdf5("glove-200-angular", "IVF16384", "SQ8Hybrid", MODE_GPU, GLOVE_INSERT_LOOPS, param_nprobes,
+                  SEARCH_LOOPS);
 #endif
 }

core/src/sdk/CMakeLists.txt

@@ -22,7 +22,7 @@ include_directories(include)
 aux_source_directory(interface interface_files)
 aux_source_directory(grpc grpc_client_files)
 
-add_library(milvus_sdk STATIC
+add_library(milvus_sdk SHARED
         ${interface_files}
         ${grpc_client_files}
         ${grpc_service_files}

core/src/sdk/README.md

+### Build C++ SDK
+
+The C++ SDK source code is under milvus/core/src/sdk. Build entire milvus project will also build the C++ SDK project. 
+If you don't want to build the entire milvus project, follow below steps:
+```shell
+ # generate make files
+ $ cd [Milvus root path]/core
+ $ ./build.sh -l
+ 
+ # build C++ SDK project
+ $ cd [Milvus root path]/core/cmake_build
+ $ make -C src/sdk
+```
+
+### Try C++ example
+
+Firstly, you need to start a Milvus server.
+If you've already built the entire milvus project, just start Milvus server with the following command:
+```shell
+ # start milvus server
+ $ cd [Milvus root path]/core
+ $ ./start_server.sh
+```
+You can also use Docker to start Milvus server:
+```shell
+ # pull milvus docker image and start milvus server
+ $ docker pull milvusdb/milvus:latest
+ $ docker run --runtime=nvidia -p 19530:19530 -d milvusdb/milvus:latest
+```
+
+Run C++ example:
+
+```shell
+ # run milvus C++ example
+ $ cd [Milvus root path]/core/cmake_build/src/sdk/examples/simple
+ $ ./sdk_simple
+```
+
+### Make your own C++ client project
+
+Create a folder for the project, and copy C++ SDK header and library files into it.
+```shell
+ # create project folder
+ $ mkdir MyMilvusClient
+ $ cd MyMilvusClient
+ 
+ # copy necessary files
+ $ cp [Milvus root path]/core/cmake_build/src/sdk/libmilvus_sdk.so .
+ $ cp [Milvus root path]/core/src/sdk/include/MilvusApi.h .
+ $ cp [Milvus root path]/core/src/sdk/include/Status.h .
+```
+
+Create file main.cpp in the project folder, and copy the following code into it:
+```shell
+#include "./MilvusApi.h"
+#include "./Status.h"
+
+int main() {
+  // connect to milvus server
+  std::shared_ptr<milvus::Connection> conn = milvus::Connection::Create();
+  milvus::ConnectParam param = {"127.0.0.1", "19530"};
+  conn->Connect(param);
+  
+  // put your client code here
+  
+  milvus::Connection::Destroy(conn);
+  return 0;
+}
+```
+
+Create file CMakeList.txt in the project folder, and copy the following code into it:
+```shell
+ cmake_minimum_required(VERSION 3.14)
+ project(test)
+ set(CMAKE_CXX_STANDARD 14)
+
+ add_executable(milvus_client main.cpp)
+ target_link_libraries(milvus_client
+         ${PROJECT_SOURCE_DIR}/libmilvus_sdk.so)
+```
+
+Now there are 5 files in your project:
+```shell
+MyMilvusClient
+ |-CMakeList.txt
+ |-main.cpp
+ |-libmilvus_sdk.so
+ |-MilvusApi.h
+ |-Status.h
+  ```
+
+Build the project:
+```shell
+ $ mkdir cmake_build
+ $ cd cmake_build
+ $ cmake ..
+ $ make
+```
+
+Run your client program:
+```shell
+ $ ./milvus_client
+```
\ No newline at end of file

core/src/sdk/examples/grpcsimple/src/ClientTest.cpp

@@ -57,22 +57,22 @@ PrintTableSchema(const milvus::TableSchema& tb_schema) {
 
 void
 PrintSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-                  const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+                  const milvus::TopKQueryResult& topk_query_result) {
     BLOCK_SPLITER
-    std::cout << "Returned result count: " << topk_query_result_array.size() << std::endl;
+    size_t nq = topk_query_result.row_num;
+    size_t topk = topk_query_result.ids.size() / nq;
+    std::cout << "Returned result count: " << nq * topk << std::endl;
 
     int32_t index = 0;
-    for (auto& result : topk_query_result_array) {
+    for (size_t i = 0; i < nq; i++) {
         auto search_id = search_record_array[index].first;
         index++;
-        std::cout << "No." << std::to_string(index) << " vector " << std::to_string(search_id) << " top "
-                  << std::to_string(result.query_result_arrays.size()) << " search result:" << std::endl;
-        for (auto& item : result.query_result_arrays) {
-            std::cout << "\t" << std::to_string(item.id) << "\tdistance:" << std::to_string(item.distance);
-            std::cout << std::endl;
+        std::cout << "No." << index << " vector " << search_id << " top " << topk << " search result:" << std::endl;
+        for (size_t j = 0; j < topk; j++) {
+            size_t idx = i * nq + j;
+            std::cout << "\t" << topk_query_result.ids[idx] << "\t" << topk_query_result.distances[idx] << std::endl;
         }
     }
-
     BLOCK_SPLITER
 }
 
@@ -166,11 +166,13 @@ class TimeRecorder {
 
 void
 CheckResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
-            const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+            const milvus::TopKQueryResult& topk_query_result) {
     BLOCK_SPLITER
+    size_t nq = topk_query_result.row_num;
+    size_t result_k = topk_query_result.ids.size() / nq;
     int64_t index = 0;
-    for (auto& result : topk_query_result_array) {
-        auto result_id = result.query_result_arrays[0].id;
+    for (size_t i = 0; i < nq; i++) {
+        auto result_id = topk_query_result.ids[i * result_k];
         auto search_id = search_record_array[index++].first;
         if (result_id != search_id) {
             std::cout << "The top 1 result is wrong: " << result_id << " vs. " << search_id << std::endl;
@@ -196,19 +198,18 @@ DoSearch(std::shared_ptr<milvus::Connection> conn,
     }
 
     auto start = std::chrono::high_resolution_clock::now();
-    std::vector<milvus::TopKQueryResult> topk_query_result_array;
+    milvus::TopKQueryResult topk_query_result;
     {
         TimeRecorder rc(phase_name);
-        milvus::Status stat =
-            conn->Search(TABLE_NAME, record_array, query_range_array, TOP_K, 32, topk_query_result_array);
+        milvus::Status stat = conn->Search(TABLE_NAME, record_array, query_range_array, TOP_K, 32, topk_query_result);
         std::cout << "SearchVector function call status: " << stat.message() << std::endl;
     }
     auto finish = std::chrono::high_resolution_clock::now();
     std::cout << "SEARCHVECTOR COST: "
               << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
 
-    PrintSearchResult(search_record_array, topk_query_result_array);
-    CheckResult(search_record_array, topk_query_result_array);
+    PrintSearchResult(search_record_array, topk_query_result);
+    CheckResult(search_record_array, topk_query_result);
 }
 }  // namespace
 

core/src/sdk/grpc/ClientProxy.cpp

@@ -188,23 +188,19 @@ ClientProxy::Insert(const std::string& table_name, const std::vector<RowRecord>&
 
         for (auto& record : record_array) {
             ::milvus::grpc::RowRecord* grpc_record = insert_param.add_row_record_array();
-            for (size_t i = 0; i < record.data.size(); i++) {
-                grpc_record->add_vector_data(record.data[i]);
-            }
+            grpc_record->add_vector_data(record.data.begin(), record.data.end());
         }
 
         // Single thread
         ::milvus::grpc::VectorIds vector_ids;
         if (!id_array.empty()) {
-            for (auto i = 0; i < id_array.size(); i++) {
-                insert_param.add_row_id_array(id_array[i]);
-            }
+            /* set user's ids */
+            insert_param.add_row_id_array(id_array.begin(), id_array.end());
             client_ptr_->Insert(vector_ids, insert_param, status);
         } else {
             client_ptr_->Insert(vector_ids, insert_param, status);
-            for (size_t i = 0; i < vector_ids.vector_id_array_size(); i++) {
-                id_array.push_back(vector_ids.vector_id_array(i));
-            }
+            /* return Milvus generated ids back to user */
+            id_array.insert(id_array.end(), vector_ids.vector_id_array().begin(), vector_ids.vector_id_array().end());
         }
 #endif
     } catch (std::exception& ex) {
@@ -217,7 +213,7 @@ ClientProxy::Insert(const std::string& table_name, const std::vector<RowRecord>&
 Status
 ClientProxy::Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
                     const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
-                    std::vector<TopKQueryResult>& topk_query_result_array) {
+                    TopKQueryResult& topk_query_result) {
     try {
         // step 1: convert vectors data
         ::milvus::grpc::SearchParam search_param;
@@ -226,9 +222,7 @@ ClientProxy::Search(const std::string& table_name, const std::vector<RowRecord>&
         search_param.set_nprobe(nprobe);
         for (auto& record : query_record_array) {
             ::milvus::grpc::RowRecord* row_record = search_param.add_query_record_array();
-            for (auto& rec : record.data) {
-                row_record->add_vector_data(rec);
-            }
+            row_record->add_vector_data(record.data.begin(), record.data.end());
         }
 
         // step 2: convert range array
@@ -239,21 +233,17 @@ ClientProxy::Search(const std::string& table_name, const std::vector<RowRecord>&
         }
 
         // step 3: search vectors
-        ::milvus::grpc::TopKQueryResultList topk_query_result_list;
-        Status status = client_ptr_->Search(topk_query_result_list, search_param);
+        ::milvus::grpc::TopKQueryResult result;
+        Status status = client_ptr_->Search(result, search_param);
 
         // step 4: convert result array
-        for (uint64_t i = 0; i < topk_query_result_list.topk_query_result_size(); ++i) {
-            TopKQueryResult result;
-            for (uint64_t j = 0; j < topk_query_result_list.topk_query_result(i).query_result_arrays_size(); ++j) {
-                QueryResult query_result;
-                query_result.id = topk_query_result_list.topk_query_result(i).query_result_arrays(j).id();
-                query_result.distance = topk_query_result_list.topk_query_result(i).query_result_arrays(j).distance();
-                result.query_result_arrays.emplace_back(query_result);
-            }
+        topk_query_result.row_num = result.row_num();
+        topk_query_result.ids.resize(result.ids().size());
+        memcpy(topk_query_result.ids.data(), result.ids().data(), result.ids().size() * sizeof(int64_t));
+        topk_query_result.distances.resize(result.distances().size());
+        memcpy(topk_query_result.distances.data(), result.distances().data(),
+               result.distances().size() * sizeof(float));
 
-            topk_query_result_array.emplace_back(result);
-        }
         return status;
     } catch (std::exception& ex) {
         return Status(StatusCode::UnknownError, "fail to search vectors: " + std::string(ex.what()));

core/src/sdk/grpc/ClientProxy.h

@@ -60,7 +60,7 @@ class ClientProxy : public Connection {
     Status
     Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
            const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
-           std::vector<TopKQueryResult>& topk_query_result_array) override;
+           TopKQueryResult& topk_query_result) override;
 
     Status
     DescribeTable(const std::string& table_name, TableSchema& table_schema) override;

core/src/sdk/grpc/GrpcClient.cpp

@@ -134,20 +134,20 @@ GrpcClient::Insert(::milvus::grpc::VectorIds& vector_ids, const ::milvus::grpc::
 }
 
 Status
-GrpcClient::Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list,
+GrpcClient::Search(::milvus::grpc::TopKQueryResult& topk_query_result,
                    const ::milvus::grpc::SearchParam& search_param) {
     ::milvus::grpc::TopKQueryResult query_result;
     ClientContext context;
-    ::grpc::Status grpc_status = stub_->Search(&context, search_param, &topk_query_result_list);
+    ::grpc::Status grpc_status = stub_->Search(&context, search_param, &topk_query_result);
 
     if (!grpc_status.ok()) {
         std::cerr << "SearchVector rpc failed!" << std::endl;
         std::cerr << grpc_status.error_message() << std::endl;
         return Status(StatusCode::RPCFailed, grpc_status.error_message());
     }
-    if (topk_query_result_list.status().error_code() != grpc::SUCCESS) {
-        std::cerr << topk_query_result_list.status().reason() << std::endl;
-        return Status(StatusCode::ServerFailed, topk_query_result_list.status().reason());
+    if (topk_query_result.status().error_code() != grpc::SUCCESS) {
+        std::cerr << topk_query_result.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, topk_query_result.status().reason());
     }
 
     return Status::OK();

core/src/sdk/grpc/GrpcClient.h

@@ -57,7 +57,7 @@ class GrpcClient {
     Insert(grpc::VectorIds& vector_ids, const grpc::InsertParam& insert_param, Status& status);
 
     Status
-    Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list, const grpc::SearchParam& search_param);
+    Search(::milvus::grpc::TopKQueryResult& topk_query_result, const grpc::SearchParam& search_param);
 
     Status
     DescribeTable(grpc::TableSchema& grpc_schema, const std::string& table_name);

core/src/sdk/include/MilvusApi.h

@@ -78,19 +78,13 @@ struct RowRecord {
     std::vector<float> data;  ///< Vector raw data
 };
 
-/**
- * @brief Query result
- */
-struct QueryResult {
-    int64_t id;       ///< Output result
-    double distance;  ///< Vector similarity distance
-};
-
 /**
  * @brief TopK query result
  */
 struct TopKQueryResult {
-    std::vector<QueryResult> query_result_arrays;  ///< TopK query result
+    int64_t row_num;
+    std::vector<int64_t> ids;
+    std::vector<float> distances;
 };
 
 /**
@@ -261,7 +255,7 @@ class Connection {
     virtual Status
     Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
            const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
-           std::vector<TopKQueryResult>& topk_query_result_array) = 0;
+           TopKQueryResult& topk_query_result) = 0;
 
     /**
      * @brief Show table description

core/src/sdk/interface/ConnectionImpl.cpp

@@ -91,9 +91,8 @@ ConnectionImpl::Insert(const std::string& table_name, const std::vector<RowRecor
 Status
 ConnectionImpl::Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
                        const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
-                       std::vector<TopKQueryResult>& topk_query_result_array) {
-    return client_proxy_->Search(table_name, query_record_array, query_range_array, topk, nprobe,
-                                 topk_query_result_array);
+                       TopKQueryResult& topk_query_result) {
+    return client_proxy_->Search(table_name, query_record_array, query_range_array, topk, nprobe, topk_query_result);
 }
 
 Status

core/src/sdk/interface/ConnectionImpl.h

@@ -62,7 +62,7 @@ class ConnectionImpl : public Connection {
     Status
     Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
            const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
-           std::vector<TopKQueryResult>& topk_query_result_array) override;
+           TopKQueryResult& topk_query_result) override;
 
     Status
     DescribeTable(const std::string& table_name, TableSchema& table_schema) override;

core/src/server/grpc_impl/GrpcServer.cpp

@@ -93,7 +93,7 @@ GrpcServer::StartService() {
 
     builder.SetCompressionAlgorithmSupportStatus(GRPC_COMPRESS_STREAM_GZIP, true);
     builder.SetDefaultCompressionAlgorithm(GRPC_COMPRESS_STREAM_GZIP);
-    builder.SetDefaultCompressionLevel(GRPC_COMPRESS_LEVEL_HIGH);
+    builder.SetDefaultCompressionLevel(GRPC_COMPRESS_LEVEL_NONE);
 
     GrpcRequestHandler service;