update tiflash proxy version to adopt bugfix from TiKV in release 6.0

.github/licenserc.yml

@@ -32,5 +32,8 @@ header:
     - '**/NOTICE'
     - 'dbms/src/IO/tests/limit_read_buffer.reference'
     - 'dbms/src/IO/tests/DevicePixelRatio'
+    - 'Cargo.lock'
+    - 'Cargo.toml'
+    - 'rust-toolchain'
 
   comment: on-failure

CMakeLists.txt

@@ -13,16 +13,12 @@
 # limitations under the License.
 
 project (TiFlash)
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 3.21)
 
 set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY true)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${TiFlash_SOURCE_DIR}/cmake/Modules/")
 set(CMAKE_MACOSX_RPATH 1)
 
-# Rust jobs may modify global toolchain settings. We make rust related jobs sequentially scheduled
-# by putting them in a job pool with single concurrency.
-set_property(GLOBAL PROPERTY JOB_POOLS rust_job_pool=1)
-
 option(TIFLASH_ENABLE_LLVM_DEVELOPMENT "enable facilities for development with LLVM" OFF)
 
 if(CMAKE_PREFIX_PATH)
@@ -111,8 +107,7 @@ endif ()
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     # clang: warning: argument unused during compilation: '-stdlib=libc++'
     # clang: warning: argument unused during compilation: '-specs=/usr/share/dpkg/no-pie-compile.specs' [-Wunused-command-line-argument]
-    # clang: warning: private field 'hash_salt' is not used [-Wunused-private-field]
-    set (COMMON_WARNING_FLAGS "${COMMON_WARNING_FLAGS} -Wno-unused-command-line-argument -Wno-unused-private-field")
+    set (COMMON_WARNING_FLAGS "${COMMON_WARNING_FLAGS} -Wno-unused-command-line-argument")
 endif ()
 
 if (ARCH_LINUX)
@@ -442,3 +437,10 @@ add_subdirectory (dbms)
 
 include (cmake/print_include_directories.cmake)
 
+# Building a rust project may require setting up toolchains. Rustup cannot handle parallel requests, hence it may fail to
+# finish the setup if multiple projects want to install a same version. To mitigate the situation, we force cargo targets
+# to be invoked sequentially by adding linear dependency relations between them.
+# Another way to do so is to use JOB_POOL with single concurrency. However, it is Ninja specific and it seems to have bugs
+# with a large number of threads.
+include (cmake/sequential.cmake)
+build_sequentially (symbolization tiflash_proxy)

README.md

@@ -1,7 +1,7 @@
 # TiFlash
 ![tiflash-architecture](tiflash-architecture.png)
 
-[TiFlash](https://docs.pingcap.com/tidb/stable/tiflash-overview) is a columnar storage component of [TiDB](https://docs.pingcap.com/tidb/stable). It mainly plays the role of Analytical Processing (AP) in the Hybrid Transactional/Analytical Processing (HTAP) architecture of TiDB. 
+[TiFlash](https://docs.pingcap.com/tidb/stable/tiflash-overview) is a columnar storage component of [TiDB](https://docs.pingcap.com/tidb/stable). It mainly plays the role of Analytical Processing (AP) in the Hybrid Transactional/Analytical Processing (HTAP) architecture of TiDB.
 
 TiFlash stores data in columnar format and synchronizes data updates in real-time from [TiKV](https://github.com/tikv/tikv) by Raft logs with sub-second latency. Reads in TiFlash are guaranteed transactionally consistent with Snapshot Isolation level. TiFlash utilizes Massively Parallel Processing (MPP) computing architecture to accelerate the analytical workloads.
 
@@ -17,122 +17,137 @@ And the following operating systems:
 * Linux
 * MacOS
 
-### Checkout Source Code
+### 1. Checkout Source Code
 
 Assume `$WORKSPACE` to be the directory under which the TiFlash repo is placed.
 
-```bash
+```shell
 cd $WORKSPACE
 git clone --recursive https://github.com/pingcap/tiflash.git
 ```
 
-### Prerequisites
+### 2. Prepare Prerequisites
 
 The following packages are needed for all platforms:
-- CMake 3.13.2+
-- Rust
-  ```bash
+
+- CMake 3.21.0+
+
+- Rust: Recommended to use [rustup](https://rustup.rs) to install:
+
+  ```shell
   curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain nightly
   source $HOME/.cargo/env
   ```
+
 - Python 3.0+
+
 - Ninja or GNU Make
 
-The following are platform-specific prerequisites.
+The following are platform-specific prerequisites. Click to expand details:
 
-#### Linux
+<details>
+  <summary><b>Linux specific prerequisites</b></summary>
 
 TiFlash can be built using either LLVM or GCC toolchain on Linux. LLVM toolchain is our official one for releasing.
 > But for GCC, only GCC 7.x is supported as far, and is not planned to be a long term support. So it may get broken some day, silently.
 
-##### LLVM 13.0.0+
+- LLVM 13.0.0+
 
-TiFlash compiles using full LLVM toolchain (`clang/compiler-rt/libc++/libc++abi`) by default.
-To quickly set up a LLVM environment, you can use TiFlash Development Environment (short as TiFlash Env, see `release-centos7-llvm/env`).
-Or you can also use system-wise toolchain if you can install `clang/compiler-rt/libc++/libc++abi` in your environment.
+  TiFlash compiles using full LLVM toolchain (`clang/compiler-rt/libc++/libc++abi`) by default.
+  To quickly set up a LLVM environment, you can use TiFlash Development Environment (short as TiFlash Env, see `release-centos7-llvm/env`).
+  You may also use a system-wise toolchain if `clang/compiler-rt/libc++/libc++abi` can be installed in your environment.
 
-###### TiFlash Env
+  Click sections below to see detailed instructions:
 
-TiFlash Env can be created with the following commands (`docker` and `tar xz` are needed):
+  <details>
+  <summary><b>Set up LLVM via TiFlash Env</b></summary>
 
-```bash
-cd $WORKSPACE/tiflash/release-centos7-llvm/env
-make tiflash-env-$(uname -m).tar.xz
-```
+  TiFlash Env can be created with the following commands (`docker` and `tar xz` are needed):
 
-Then copy and uncompress `tiflash-env-$(uname -m).tar.xz` to a suitable place, assuming `$TIFLASH_ENV`.
+  ```shell
+  cd $WORKSPACE/tiflash/release-centos7-llvm/env
+  make tiflash-env-$(uname -m).tar.xz
+  ```
 
-To enter the env (before compiling TiFlash):
+  Then copy and uncompress `tiflash-env-$(uname -m).tar.xz` to a suitable place, assuming `$TIFLASH_ENV`.
 
-```bash
-cd $TIFLASH_ENV
-./loader
-```
+  To enter the env (before compiling TiFlash):
 
-Or you can dump the env settings and put them to the end of your `~/.bashrc` or `~/.zshrc`
+  ```shell
+  cd $TIFLASH_ENV
+  ./loader
+  ```
 
-```bash
-cd $TIFLASH_ENV
-./loader-env-dump
-```
+  Or you can dump the env settings and put them to the end of your `~/.bashrc` or `~/.zshrc`
+
+  ```shell
+  cd $TIFLASH_ENV
+  ./loader-env-dump
+  ```
 
-###### System-wise Toolchain
+  </details>
 
-- Debian/Ubuntu users:
+  <details>
+  <summary><b>Set up LLVM via package managers in Debian/Ubuntu</b></summary>
 
-  ```bash
+  ```shell
   # add LLVM repo key
-  wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add - 
+  wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add -
 
   # install LLVM packages
-  apt-get install clang-13 lldb-13 lld-13 clang-tools-13 clang-13-doc libclang-common-13-dev libclang-13-dev libclang1-13 clang-format-13 clangd-13 clang-tidy-13 libc++-13-dev libc++abi-13-dev libomp-13-dev llvm-13-dev libfuzzer-13-dev 
-
-  # install rust
-  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+  apt-get install clang-13 lldb-13 lld-13 clang-tools-13 clang-13-doc libclang-common-13-dev libclang-13-dev libclang1-13 clang-format-13 clangd-13 clang-tidy-13 libc++-13-dev libc++abi-13-dev libomp-13-dev llvm-13-dev libfuzzer-13-dev
 
   # install other dependencies
   apt-get install lcov cmake ninja-build libssl-dev zlib1g-dev libcurl4-openssl-dev
   ```
 
-- Archlinux users:
+  </details>
+
+  <details>
+  <summary><b>Set up LLVM via package managers in Archlinux</b></summary>
 
-  ```bash
+  ```shell
   # install compilers and dependencies
   sudo pacman -S clang libc++ libc++abi compiler-rt openmp lcov cmake ninja curl openssl zlib
-
-  # install rust
-  curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-  ``` 
+  ```
+
+  </details>
 
-##### GCC 7.x
+- GCC 7.x
 
-> **WARNING**: This support may not be maintained in the future.
+  > **WARNING**: This support may not be maintained in the future.
 
-TiFlash compiles on GCC 7.x (no older, nor newer) only because it hasn't been broken. If you have GCC 7.x, you are probably fine, for now.
+  TiFlash compiles on GCC 7.x (no older, nor newer) only because it hasn't been broken. If you have GCC 7.x, you are probably fine, for now.
 
-#### MacOS
+</details>
+
+<details>
+  <summary><b>MacOS specific prerequisites</b></summary>
 
 - Apple Clang 12.0.0+
 - OpenSSL 1.1
-  ```bash
+
+  ```shell
   brew install [email protected]
   ```
 
-### Build
+</details>
+
+### 3. Build
 
 Assume `$BUILD` to be the directory under which you want to build TiFlash.
 
 For Ninja:
 
-```bash
+```shell
 cd $BUILD
 cmake $WORKSPACE/tiflash -Gninja
 ninja tiflash
 ```
 
 For GNU Make:
 
-```bash
+```shell
 cd $BUILD
 cmake $WORKSPACE/tiflash
 make tiflash -j
@@ -142,57 +157,73 @@ After building, you can get TiFlash binary under `$BUILD/dbms/src/Server/tiflash
 
 ### Build Options
 
-TiFlash has several build options to tweak the build, mostly for development purposes.
+TiFlash has several CMake build options to tweak for development purposes. These options SHOULD NOT be changed for production usage, as they may introduce unexpected build errors and unpredictable runtime behaviors.
 
-> **WARNING**: These options SHOULD NOT be tuned for production usage, as they may introduce unexpected build errors and unpredictable runtime behaviors.
+To tweat options, pass one or multiple `-D...=...` args when invoking CMake, for example:
 
-They are all CMake options thus are specified using `-D...=...`s in CMake command line.
+```shell
+cmake $WORKSPACE/tiflash -DCMAKE_BUILD_TYPE=DEBUG
+```
 
-#### Build Types
+- **Build Type**:
 
-- `CMAKE_BUILD_TYPE`: `DEBUG` / `RELWITHDEBINFO` (default) / `RELEASE`
+  - `-DCMAKE_BUILD_TYPE=RELWITHDEBINFO`: Release build with debug info (default)
 
-#### Build with Unit Tests
+  - `-DCMAKE_BUILD_TYPE=DEBUG`: Debug build
 
-- `ENABLE_TESTS`: `ON` / `OFF` (default)
+  - `-DCMAKE_BUILD_TYPE=RELEASE`: Release build
 
-#### Build with System Libraries
+- **Build with Unit Tests**:
 
-For local development, it is sometimes handy to use pre-installed third-party libraries in the system, rather than to compile them from sources of the bundled (internal) submodules.
+  - `-DENABLE_TESTS=OFF`: Default
 
-Options are supplied to control whether to use internal third-party libraries (bundled in TiFlash) or to try using the pre-installed system ones.
+  - `-DENABLE_TESTS=ON`
 
-> **WARNING**: It is NOT guaranteed that TiFlash would still build if any of the system libraries are used.
-> Build errors are very likely to happen, almost all the time.
+- **Build with System Libraries**:
 
-You can view these options along with their descriptions by running:
+  <details>
+  <summary>Click to expand instructions</summary>
 
-```bash
-cd $BUILD
-cmake -LH | grep "USE_INTERNAL" -A3
-```
+  For local development, it is sometimes handy to use pre-installed third-party libraries in the system, rather than to compile them from sources of the bundled (internal) submodules.
+
+  Options are supplied to control whether to use internal third-party libraries (bundled in TiFlash) or to try using the pre-installed system ones.
+
+  > **WARNING**: It is NOT guaranteed that TiFlash would still build if any of the system libraries are used.
+  > Build errors are very likely to happen, almost all the time.
+
+  You can view these options along with their descriptions by running:
+
+  ```shell
+  cd $BUILD
+  cmake -LH | grep "USE_INTERNAL" -A3
+  ```
+
+  All of these options are default as `ON`, as the names tell, using the internal libraries and build from sources.
+
+  There is another option to append extra paths for CMake to find system libraries:
+
+  - `PREBUILT_LIBS_ROOT`: Default as empty, can be specified with multiple values, seperated by `;`
 
-All of these options are default as `ON`, as the names tell, using the internal libraries and build from sources.
+  Specifically, for [TiFlash proxy](https://github.com/pingcap/tidb-engine-ext):
 
-There is another option to append extra paths for CMake to find system libraries:
+  - `USE_INTERNAL_TIFLASH_PROXY=TRUE` (default) / `FALSE`
 
-- `PREBUILT_LIBS_ROOT`: Default as empty, can be specified with multiple values, seperated by `;`
+    One may want to use external TiFlash proxy, e.g., if he is developing TiFlash proxy together with TiFlash, assume `$TIFLASH_PROXY_REPO` to be the path to the external TiFlash proxy repo
 
-Specifically, for [TiFlash proxy](https://github.com/pingcap/tidb-engine-ext):
+    Usually need to be combined with `PREBUILT_LIBS_ROOT=$TIFLASH_PROXY_REPO`, and `$TIFLASH_PROXY_REPO` should have the following directory structure:
 
-- `USE_INTERNAL_TIFLASH_PROXY`: `TRUE` (default) / `FALSE`
-  - One may want to use external TiFlash proxy, e.g., if he is developing TiFlash proxy together with TiFlash, assume `$TIFLASH_PROXY_REPO` to be the path to the external TiFlash proxy repo
-  - Usually need to be combined with `PREBUILT_LIBS_ROOT=$TIFLASH_PROXY_REPO`, and `$TIFLASH_PROXY_REPO` should have the following directory structure:
     - Header files are under directory `$TIFLASH_PROXY_REPO/raftstore-proxy/ffi/src`
+
     - Built library is under directory `$TIFLASH_PROXY_REPO/target/release`
 
+  </details>
 ### IDE Support
 
 Normally a CMake-based IDE, e.g., Clion and VSCode, should be able to open TiFlash project with no pain as long as the toolchains are properly configured.
 
 If your toolchain is set up using [TiFlash Env](#tiflash-env), and you may not want to add those libs to your system loader config, you can pass the following CMake options to your IDE:
 
-```
+```shell
 -DCMAKE_PREFIX_PATH=$TIFLASH_ENV
 ```
 
@@ -212,7 +243,7 @@ TBD.
 [//]: <> (TODO: Should refine to use local commands rather than docker.)
 To get a coverage report of unit tests, we recommend using the docker image and our scripts.
 
-```
+```shell
 docker run --rm -it -v /path/to/tiflash/src:/build/tiflash hub.pingcap.net/tiflash/tiflash-llvm-base:amd64 /bin/bash # or aarch64
 cd /build/tiflash/release-centos7-llvm
 sh scripts/build-tiflash-ut-coverage.sh
@@ -246,7 +277,7 @@ Before submitting a pull request, please use [format-diff.py](format-diff.py) to
 
 > **NOTE**: It is required to use clang-format 12.0.0+.
 
-```
+```shell
 cd $WORKSPACE/tiflash
 python3 format-diff.py --diff_from `git merge-base ${TARGET_REMOTE_BRANCH} HEAD`
 ```

cmake/Modules/FindPoco.cmake

@@ -114,7 +114,7 @@ endif()
 
 # if installed directory structure, set full include dir
 if(Poco_INSTALLED)
-    set(Poco_INCLUDE_DIRS ${Poco_ROOT_DIR}/include/ CACHE PATH "The global include path for Poco")
+    set(Poco_INCLUDE_DIRS ${Poco_ROOT_DIR}/include/)
 endif()
 
 # append the default minimum components to the list to find

cmake/find_tiflash_proxy.cmake

@@ -50,3 +50,7 @@ endif()
 set(TIFLASH_PROXY_FOUND TRUE)
 
 message(STATUS "Using tiflash proxy: ${USE_INTERNAL_TIFLASH_PROXY} : ${TIFLASH_PROXY_INCLUDE_DIR}, ${TIFLASH_PROXY_LIBRARY}")
+
+if (NOT USE_INTERNAL_TIFLASH_PROXY)
+    add_custom_target(tiflash_proxy ALL DEPENDS ${TIFLASH_PROXY_LIBRARY})
+endif()