A cloud-native vector database, storage for next generation AI applications
 
 
 
 
 
 
Go to file
shaoting-huang de7901121f
Upgrade go from 1.20 to 1.21 (#33047)
Signed-off-by: shaoting-huang [shaoting-huang@zilliz.com]

issue: https://github.com/milvus-io/milvus/issues/32982

# Background
Go 1.21 introduces several improvements and changes over Go 1.20, which
is quite stable now. According to
[Go 1.21 Release Notes](https://tip.golang.org/doc/go1.21), the big
difference of Go 1.21 is enabling Profile-Guided Optimization by
default, which can improve performance by around 2-14%. Here are the
summary steps of PGO:
1. Build Initial Binary (Without PGO)
2. Deploying the Production Environment
3. Run the program and collect Performance Analysis Data (CPU pprof)
4. Analyze the Collected Data and Select a Performance Profile for PGO
5. Place the Performance Analysis File in the Main Package Directory and
Name It default.pgo
6. go build Detects the default.pgo File and Enables PGO
7. Build and Release the Updated Binary (With PGO)
8. Iterate and Repeat the Above Steps
<img width="657" alt="Screenshot 2024-05-14 at 15 57 01"
src="https://github.com/milvus-io/milvus/assets/167743503/b08d4300-0be1-44dc-801f-ce681dabc581">

# What does this PR do
There are three experiments, search benchmark by Zilliz test platform,
search benchmark by open-source
[VectorDBBench](https://github.com/zilliztech/VectorDBBench?tab=readme-ov-file),
and search benchmark with PGO. We do both search benchmarks by Zilliz
test platform and by VectorDBBench to reduce reliance on a single
experimental result. Besides, we validate the performance enhancement
with PGO.

## Search Benchmark Report by Zilliz Test Platform
An upgrade to Go 1.21 was conducted on a Milvus Standalone server,
equipped with 16 CPUs and 64GB of memory. The search performance was
evaluated using a 1 million entry local dataset with an L2 metric type
in a 768-dimensional space. The system was tested for concurrent
searches with 50 concurrent tasks for 1 hour, each with a 20-second
interval. The reason for using one server rather than two servers to
compare is to guarantee the same data source and same segment state
after compaction.

Test Sequence:
1. Go 1.20 Initial Run: Insert data, build index, load index, and
search.
2. Go 1.20 Rebuild: Rebuild the index with the same dataset, load index,
and search.
3. Go 1.21 Load: Upload to Go 1.21 within the server. Then load the
index from the second run, and search.
4. Go 1.21 Rebuild: Rebuild the index with the same dataset, load index,
and search.

Search Metrics: 
| Metric | Go 1.20 | Go 1.20 Rebuild Index | Go 1.21 | Go 1.21 Rebuild
Index |

|----------------------------|------------------|-----------------|------------------|-----------------|
| `search requests` | 10,942,683 | 16,131,726 | 16,200,887 | 16,331,052
|
| `search fails` | 0 | 0 | 0 | 0 |
| `search RT_avg` (ms) | 16.44 | 11.15 | 11.11 | 11.02 |
| `search RT_min` (ms) | 1.30 | 1.28 | 1.31 | 1.26 |
| `search RT_max` (ms) | 446.61 | 233.22 | 235.90 | 147.93 |
| `search TP50` (ms) | 11.74 | 10.46 | 10.43 | 10.35 |
| `search TP99` (ms) | 92.30 | 25.76 | 25.36 | 25.23 |
| `search RPS` | 3,039 | 4,481 | 4,500 | 4,536 |

### Key Findings
The benchmark tests reveal that the index build time with Go 1.20 at
340.39 ms and Go 1.21 at 337.60 ms demonstrated negligible performance
variance in index construction. However, Go 1.21 offers slightly better
performance in search operations compared to Go 1.20, with improvements
in handling concurrent tasks and reducing response times.

## Search Benchmark Report By VectorDb Bench
Follow
[VectorDBBench](https://github.com/zilliztech/VectorDBBench?tab=readme-ov-file)
to create a VectorDb Bench test for Go 1.20 and Go 1.21. We test the
search performance with Go 1.20 and Go 1.21 (without PGO) on the Milvus
Standalone system. The tests were conducted using the Cohere dataset
with 1 million entries in a 768-dimensional space, utilizing the COSINE
metric type.

Search Metrics: 
Metric | Go 1.20 | Go 1.21 without PGO
-- | -- | --
Load Duration (seconds) | 1195.95 | 976.37
Queries Per Second (QPS) | 841.62 | 875.89
99th Percentile Serial Latency (seconds) | 0.0047 | 0.0076
Recall | 0.9487 | 0.9489

### Key Findings
Go 1.21 indicates faster index loading times and larger search QPS
handling.

## PGO Performance Test
Milvus has already added
[net/http/pprof](https://pkg.go.dev/net/http/pprof) in the metrics. So
we can curl the CPU profile directly by running
`curl -o default.pgo
"http://${MILVUS_SERVER_IP}:${MILVUS_SERVER_PORT}/debug/pprof/profile?seconds=${TIME_SECOND}"`
to collect the profile as the default.pgo during the first search. Then
I build Milvus with PGO and use the same index to run the search again.
The result is as below:

Search Metrics
| Metric | Go 1.21 Without PGO | Go 1.21 With PGO | Change (%) |

|---------------------------------------------|------------------|-----------------|------------|
| `search Requests` | 2,644,583 | 2,837,726 | +7.30% |
| `search Fails` | 0 | 0 | N/A |
| `search RT_avg` (ms) | 11.34 | 10.57 | -6.78% |
| `search RT_min` (ms) | 1.39 | 1.32 | -5.18% |
| `search RT_max` (ms) | 349.72 | 143.72 | -58.91% |
| `search TP50` (ms) | 10.57 | 9.93 | -6.05% |
| `search TP99` (ms) | 26.14 | 24.16 | -7.56% |
| `search RPS`                 | 4,407       | 4,729       | +7.30%    |

### Key Findings
PGO led to a notable enhancement in search performance, particularly in
reducing the maximum response time by 58% and increasing the search QPS
by 7.3%.

### Further Analysis
Generate a diff flame graphs between two CPU profiles by running `go
tool pprof -http=:8000 -diff_base nopgo.pgo pgo.pgo -normalize`

<img width="1894" alt="goprofiling"
src="https://github.com/milvus-io/milvus/assets/167743503/ab9e91eb-95c7-4963-acd9-d1c3c73ee010">
Further insight of HnswIndexNode and Milvus Search Handler
<img width="1906" alt="hnsw"
src="https://github.com/milvus-io/milvus/assets/167743503/a04cf4a0-7c97-4451-b3cf-98afc20a0b05">
<img width="1873" alt="search_handler"
src="https://github.com/milvus-io/milvus/assets/167743503/5f4d3982-18dd-4115-8e76-460f7f534c7f">

After applying PGO to the Milvus server, the CPU utilization of the
faiss::fvec_L2 function has decreased. This optimization significantly
enhances the performance of the
[HnswIndexNode::Search::searchKnn](e0c9c41aa2/src/index/hnsw/hnsw.cc (L203))
method, which is frequently invoked by Knowhere during high-concurrency
searches. As the explanation from Go release notes, the function might
be more aggressively inlined by Go compiler during the second build with
the CPU profiling collected from the first run. As a result, the search
handler efficiency within Milvus DataNode has improved, allowing the
server to process a higher number of search queries per second (QPS).



# Conclusion
The combination of Go 1.21 and PGO has led to substantial enhancements
in search performance for Milvus server, particularly in terms of search
QPS and response times, making it more efficient for handling
high-concurrency search operations.

Signed-off-by: shaoting-huang <shaoting.huang@zilliz.com>
2024-05-22 13:21:39 +08:00
.github enhance: Sync go.mod version & dep to main pkg (#32973) 2024-05-13 10:25:32 +08:00
build enhance: upgrade amazonlinux2023 builder image go version to 1.21 (#33176) 2024-05-20 21:11:39 +08:00
ci/jenkins feat: support arm-based image build and pull request (#33219) 2024-05-21 16:54:38 +08:00
client enhance: Add lint rules for client pkg and fix problems (#33180) 2024-05-20 20:47:38 +08:00
cmd enhance: remove fallback keys for config generator (#32946) 2024-05-13 13:33:31 +08:00
configs Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
deployments enhance: fix the dev docker yaml and use `go install` to install the gotestsum (#32197) 2024-04-12 19:17:18 +08:00
docs doc: fix typos in design docs (#32885) 2024-05-09 15:43:30 +08:00
githooks [skip ci]Update OWNERS files (#11898) 2021-11-16 15:41:11 +08:00
internal enhance: Upgrade bitset for ARM SVE (#32718) 2024-05-22 11:37:40 +08:00
pkg enhance: add config to control whether to init public role permissions (#33165) 2024-05-21 22:39:46 +08:00
scripts Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
tests feat: support arm-based image build and pull request (#33219) 2024-05-21 16:54:38 +08:00
tools upgrade Go 1.18 in go.mod (#18165) 2022-08-01 14:28:33 +08:00
.clang-format Re-format cpp code (#22513) 2023-03-02 15:55:49 +08:00
.clang-tidy Fix spawn too many threads (#26293) 2023-08-11 18:29:29 +08:00
.clang-tidy-ignore Add cpplint and optimize the check of c++ code 2020-11-23 19:57:05 +08:00
.contributors [skip ci]Update all-contributors (#6358) 2021-07-08 12:03:08 +08:00
.devcontainer.json Update main.yaml for Github Action (#6381) 2021-07-09 11:59:09 +08:00
.dockerignore Add dockerignore for building milvus image (#28102) 2023-11-03 14:28:17 +08:00
.env [automated] Update cpu Builder image changes (#32705) 2024-05-07 09:57:30 +08:00
.gitignore enhance: ignore proto generated files (#28537) 2023-11-22 10:20:22 +08:00
.golangci.yml Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
.pre-commit-config.yaml enhance: [skip e2e]remove slow pre commit (#31397) 2024-03-19 16:29:06 +08:00
CODE_OF_CONDUCT.md [skip ci]Format markdown doc for CODE_OF_CONDUCT.md (#10042) 2021-10-17 16:44:40 +08:00
CODE_REVIEW.md [skip e2e]Fix a grammar issue (#15086) 2022-01-10 22:30:23 +08:00
COMMAND_HELP.md Update docs for run-cpu-e2e (#18520) 2022-08-03 17:04:36 +08:00
COMMITTERS Update COMMITTERS 2023-02-15 16:11:11 +08:00
CONTRIBUTING.md Update CONTRIBUTING.md for mockery generation (#26842) 2023-09-05 14:11:54 +08:00
DEVELOPMENT.md Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
LICENSE Update README 2021-04-21 14:04:22 +08:00
MAINTAINERS Update maintainers list 2023-02-15 16:07:41 +08:00
Makefile Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
OWNERS [skip ci]Add GitHub label for compilation changes (#12894) 2021-12-07 19:37:04 +08:00
OWNERS_ALIASES [skip e2e] Update OWNERS_ALIASES for approve label (#22223) 2023-02-16 16:38:35 +08:00
README.md Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
README_CN.md Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
codecov.yml Refactor task scheduler and executor (#20828) 2022-11-30 13:57:15 +08:00
docker-compose.yml enhance: [skip e2e]upgrade minio version (#28971) 2023-12-05 14:14:34 +08:00
go.mod Upgrade go from 1.20 to 1.21 (#33047) 2024-05-22 13:21:39 +08:00
go.sum enhance: sync milvus proto version (#33094) 2024-05-16 18:51:34 +08:00
milvus20vs1x.md docs: update table, show feat status with badge (#19624) (#19624) 2022-10-08 13:52:57 +08:00
rules.go Format the code (#27275) 2023-09-21 09:45:27 +08:00

README.md

milvus banner
license license docker-pull-count

What is Milvus?

milvus-logo

Milvus is an open-source vector database built to power embedding similarity search and AI applications. Milvus makes unstructured data search more accessible, and provides a consistent user experience regardless of the deployment environment.

Milvus 2.0 is a cloud-native vector database with storage and computation separated by design. All components in this refactored version of Milvus are stateless to enhance elasticity and flexibility. For more architecture details, see Milvus Architecture Overview.

Milvus was released under the open-source Apache License 2.0 in October 2019. It is currently a graduate project under LF AI & Data Foundation.

Key features

Millisecond search on trillion vector datasets Average latency measured in milliseconds on trillion vector datasets.
Simplified unstructured data management
  • Rich APIs designed for data science workflows.
  • Consistent user experience across laptop, local cluster, and cloud.
  • Embed real-time search and analytics into virtually any application.
  • Reliable, always on vector database Milvus built-in replication and failover/failback features ensure data and applications can maintain business continuity in the event of a disruption.
    Highly scalable and elastic Component-level scalability makes it possible to scale up and down on demand. Milvus can autoscale at a component level according to the load type, making resource scheduling much more efficient.
    Hybrid search In addition to vectors, Milvus supports data types such as Boolean, integers, floating-point numbers, and more. A collection in Milvus can hold multiple fields for accommodating different data features or properties. Milvus pairs scalar filtering with powerful vector similarity search to offer a modern, flexible platform for analyzing unstructured data. Check https://github.com/milvus-io/milvus/wiki/Hybrid-Search for examples and boolean expression rules.
    Unified Lambda structure Milvus combines stream and batch processing for data storage to balance timeliness and efficiency. Its unified interface makes vector similarity search a breeze.
    Community supported, industry recognized With over 1,000 enterprise users, 9,000+ stars on GitHub, and an active open-source community, youre not alone when you use Milvus. As a graduate project under the LF AI & Data Foundation, Milvus has institutional support.

    Quick start

    Start with Zilliz Cloud

    Zilliz Cloud is a fully managed service on cloud and the simplest way to deploy LF AI Milvus®, See Zilliz Cloud and start your free trial.

    Install Milvus

    Build Milvus from source code

    Check the requirements first.

    Linux systems (Ubuntu 20.04 or later recommended):

    go: >= 1.21
    cmake: >= 3.26.4
    gcc: 7.5
    

    MacOS systems with x86_64 (Big Sur 11.5 or later recommended):

    go: >= 1.21
    cmake: >= 3.26.4
    llvm: >= 15
    

    MacOS systems with Apple Silicon (Monterey 12.0.1 or later recommended):

    go: >= 1.21 (Arch=ARM64)
    cmake: >= 3.26.4
    llvm: >= 15
    

    Clone Milvus repo and build.

    # Clone github repository.
    $ git clone https://github.com/milvus-io/milvus.git
    
    # Install third-party dependencies.
    $ cd milvus/
    $ ./scripts/install_deps.sh
    
    # Compile Milvus.
    $ make
    

    For the full story, see developer's documentation.

    IMPORTANT The master branch is for the development of Milvus v2.0. On March 9th, 2021, we released Milvus v1.0, the first stable version of Milvus with long-term support. To use Milvus v1.0, switch to branch 1.0.

    Milvus 2.0 vs. 1.x: Cloud-native, distributed architecture, highly scalable, and more

    See Milvus 2.0 vs. 1.x for more information.

    Real world demos

    Image search Chatbots Chemical structure search

    Images made searchable. Instantaneously return the most similar images from a massive database.

    Chatbots

    Interactive digital customer service that saves users time and businesses money.

    Blazing fast similarity search, substructure search, or superstructure search for a specified molecule.

    Bootcamps

    Milvus bootcamp is designed to expose users to both the simplicity and depth of the vector database. Discover how to run benchmark tests as well as build similarity search applications spanning chatbots, recommendation systems, reverse image search, molecular search, and much more.

    Contributing

    Contributions to Milvus are welcome from everyone. See Guidelines for Contributing for details on submitting patches and the contribution workflow. See our community repository to learn about our governance and access more community resources.

    All contributors




    Documentation

    For guidance on installation, development, deployment, and administration, check out Milvus Docs. For technical milestones and enhancement proposals, check out milvus confluence

    SDK

    The implemented SDK and its API documentation are listed below:

    Attu

    Attu provides an intuitive and efficient GUI for Milvus.

    Community

    Join the Milvus community on Discord to share your suggestions, advice, and questions with our engineering team.

    You can also check out our FAQ page to discover solutions or answers to your issues or questions.

    Subscribe to Milvus mailing lists:

    Follow Milvus on social media:

    Reference

    Reference to cite when you use Milvus in a research paper:

    @inproceedings{2021milvus,
      title={Milvus: A Purpose-Built Vector Data Management System},
      author={Wang, Jianguo and Yi, Xiaomeng and Guo, Rentong and Jin, Hai and Xu, Peng and Li, Shengjun and Wang, Xiangyu and Guo, Xiangzhou and Li, Chengming and Xu, Xiaohai and others},
      booktitle={Proceedings of the 2021 International Conference on Management of Data},
      pages={2614--2627},
      year={2021}
    }
    
    @article{2022manu,
      title={Manu: a cloud native vector database management system},
      author={Guo, Rentong and Luan, Xiaofan and Xiang, Long and Yan, Xiao and Yi, Xiaomeng and Luo, Jigao and Cheng, Qianya and Xu, Weizhi and Luo, Jiarui and Liu, Frank and others},
      journal={Proceedings of the VLDB Endowment},
      volume={15},
      number={12},
      pages={3548--3561},
      year={2022},
      publisher={VLDB Endowment}
    }
    

    Acknowledgments

    Milvus adopts dependencies from the following:

    • Thanks to FAISS for the excellent search library.
    • Thanks to etcd for providing great open-source key-value store tools.
    • Thanks to Pulsar for its wonderful distributed pub-sub messaging system.
    • Thanks to Tantivy for its full-text search engine library written in Rust.
    • Thanks to RocksDB for the powerful storage engines.

    Milvus is adopted by following opensource project:

    • Towhee a flexible, application-oriented framework for computing embedding vectors over unstructured data.
    • Haystack an open source NLP framework that leverages Transformer models
    • Langchain Building applications with LLMs through composability
    • LLamaIndex a data framework for your LLM applications
    • GPTCache a library for creating semantic cache to store responses from LLM queries.