Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/apache/kudu

Mirror of Apache Kudu
https://github.com/apache/kudu

big-data cplusplus kudu

Last synced: 4 days ago
JSON representation

Mirror of Apache Kudu

Awesome Lists containing this project

README 

        
// 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.

= Kudu Developer Documentation



== Building and installing Kudu



Follow the steps in the

https://kudu.apache.org/docs/installation.html#build_from_source[documentation]

to build and install Kudu from source



=== Building Kudu out of tree



A single Kudu source tree may be used for multiple builds, each with its

own build directory. Build directories may be placed anywhere in the

filesystem with the exception of the root directory of the source tree. The

Kudu build is invoked with a working directory of the build directory

itself, so you must ensure it exists (i.e. create it with _mkdir -p_). It's

recommended to place all build directories within the _build_ subdirectory;

_build/latest_ will be symlinked to most recently created one.



The rest of this document assumes the build directory

_/build/debug_.



=== Automatic rebuilding of dependencies



The script `thirdparty/build-if-necessary.sh` is invoked by cmake, so

new thirdparty dependencies added by other developers will be downloaded

and built automatically in subsequent builds if necessary.



To disable the automatic invocation of `build-if-necessary.sh`, set the

`NO_REBUILD_THIRDPARTY` environment variable:



[source,bash]

----

$ cd build/debug

$ NO_REBUILD_THIRDPARTY=1 cmake ../..

----



This can be particularly useful when trying to run tools like `git bisect`

between two commits which may have different dependencies.



=== Building Kudu itself



[source,bash]

----

# Add /thirdparty/installed/common/bin to your $PATH

# before other parts of $PATH that may contain cmake, such as /usr/bin

# For example: "export PATH=$HOME/git/kudu/thirdparty/installed/common/bin:$PATH"

# if using bash.

$ mkdir -p build/debug

$ cd build/debug

$ cmake ../..

$ make -j8  # or whatever level of parallelism your machine can handle

----



The build artifacts, including the test binaries, will be stored in

_build/debug/bin/_.



To omit the Kudu unit tests during the build, add -DNO_TESTS=1 to the

invocation of cmake. For example:



[source,bash]

----

$ cd build/debug

$ cmake -DNO_TESTS=1 ../..

----



== Running unit/functional tests



To run the Kudu unit tests, you can use the `ctest` command from within the

_build/debug_ directory:



[source,bash]

----

$ cd build/debug

$ ctest -j8

----



This command will report any tests that failed, and the test logs will be

written to _build/debug/test-logs_.



Individual tests can be run by directly invoking the test binaries in

_build/debug/bin_. Since Kudu uses the Google C++ Test Framework (gtest),

specific test cases can be run with gtest flags:



[source,bash]

----

# List all the tests within a test binary, then run a single test

$ build/debug/bin/tablet-test --gtest_list_tests

$ build/debug/bin/tablet-test --gtest_filter=TestTablet/9.TestFlush

----



gtest also allows more complex filtering patterns. See the upstream

documentation for more details.



=== Running tests with the clang AddressSanitizer enabled



AddressSanitizer is a nice clang feature which can detect many types of memory

errors. The Jenkins setup for kudu runs these tests automatically on a regular

basis, but if you make large changes it can be a good idea to run it locally

before pushing. To do so, you'll need to build using `clang`:



[source,bash]

----

$ mkdir -p build/asan

$ cd build/asan

$ CC=../../thirdparty/clang-toolchain/bin/clang \

  CXX=../../thirdparty/clang-toolchain/bin/clang++ \

  ../../thirdparty/installed/common/bin/cmake \

  -DKUDU_USE_ASAN=1 ../..

$ make -j8

$ ctest -j8

----



The tests will run significantly slower than without ASAN enabled, and if any

memory error occurs, the test that triggered it will fail. You can then use a

command like:



[source,bash]

----

$ cd build/asan

$ ctest -R failing-test

----



to run just the failed test.



NOTE: For more information on AddressSanitizer, please see the

https://clang.llvm.org/docs/AddressSanitizer.html[ASAN web page].



=== Running tests with the clang Undefined Behavior Sanitizer (UBSAN) enabled



Similar to the above, you can use a special set of clang flags to enable the Undefined

Behavior Sanitizer. This will generate errors on certain pieces of code which may

not themselves crash but rely on behavior which isn't defined by the C++ standard

(and thus are likely bugs). To enable UBSAN, follow the same directions as for

ASAN above, but pass the `-DKUDU_USE_UBSAN=1` flag to the `cmake` invocation.



In order to get a stack trace from UBSan, you can use gdb on the failing test, and

set a breakpoint as follows:



----

(gdb) b __ubsan::Diag::~Diag

----



Then, when the breakpoint fires, gather a backtrace as usual using the `bt` command.



=== Running tests with ThreadSanitizer enabled



ThreadSanitizer (TSAN) is a feature of recent Clang and GCC compilers which can

detect improperly synchronized access to data along with many other threading

bugs. To enable TSAN, pass `-DKUDU_USE_TSAN=1` to the `cmake` invocation,

recompile, and run tests. For example:



[source,bash]

----

$ mkdir -p build/tsan

$ cd build/tsan

$ CC=../../thirdparty/clang-toolchain/bin/clang \

    CXX=../../thirdparty/clang-toolchain/bin/clang++ \

    ../../thirdparty/installed/common/bin/cmake \

    -DKUDU_USE_TSAN=1 ../..

$ make -j8

$ ctest -j8

----



TSAN may truncate a few lines of the stack trace when reporting where the error

is. This can be bewildering. It's documented for TSANv1 here:

https://code.google.com/p/data-race-test/wiki/ThreadSanitizerAlgorithm

It is not mentioned in the documentation for TSANv2, but has been observed.

In order to find out what is _really_ happening, set a breakpoint on the TSAN

report in GDB using the following incantation:



[source,bash]

----

$ gdb -ex 'set disable-randomization off' -ex 'b __tsan::PrintReport' ./some-test

----



=== Generating code coverage reports



In order to generate a code coverage report, you must use the following flags:



[source,bash]

----

$ mkdir -p build/coverage

$ cd build/coverage

$ CC=../../thirdparty/clang-toolchain/bin/clang \

  CXX=../../thirdparty/clang-toolchain/bin/clang++ \

  cmake -DKUDU_GENERATE_COVERAGE=1 ../..

$ make -j4

$ ctest -j4

----



This will generate the code coverage files with extensions .gcno and .gcda. You can then

use a tool like `gcovr` or `llvm-cov gcov` to visualize the results. For example, using

gcovr:



[source,bash]

----

$ cd build/coverage

$ mkdir cov_html

$ ../../thirdparty/installed/common/bin/gcovr \

      --gcov-executable=$(pwd)/../../build-support/llvm-gcov-wrapper \

      --html --html-details -o cov_html/coverage.html

----



Then open `cov_html/coverage.html` in your web browser.



=== Running lint checks



Kudu uses cpplint.py from Google to enforce coding style guidelines. You can run the

lint checks via cmake using the `ilint` target:



[source,bash]

----

$ make ilint

----



This will scan any file which is dirty in your working tree, or changed since the last

gerrit-integrated upstream change in your git log. If you really want to do a full

scan of the source tree, you may use the `lint` target instead.



=== Running clang-tidy checks



Kudu also uses the clang-tidy tool from LLVM to enforce coding style

guidelines. You can run the tidy checks via cmake using the `tidy` target:



[source,bash]

----

$ make tidy

----



This will scan any changes in the latest commit in the local tree. At the time

of writing, it will not scan any changes that are not locally committed.



=== Running include-what-you-use (IWYU) checks



Kudu uses the https://github.com/include-what-you-use/include-what-you-use[IWYU]

tool to keep the set of headers in the C++ source files consistent. For more

information on what _consistent_ means, see

https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/WhyIWYU.md[_Why IWYU_].



You can run the IWYU checks via cmake using the `iwyu` target:



[source,bash]

----

$ make iwyu

----



This will scan any file which is dirty in your working tree, or changed since the last

gerrit-integrated upstream change in your git log.



If you want to run against a specific file, or against all files, you can use the

`iwyu.py` script:



[source,bash]

----

$ ./build-support/iwyu.py

----



See the output of `iwyu.py --help` for details on various modes of operation.



[[building-docs]]

=== Building Kudu documentation



Kudu's documentation is written in asciidoc and lives in the _docs_ subdirectory.



To build the documentation (this is primarily useful if you would like to

inspect your changes before submitting them to Gerrit), use the `docs` target:



[source,bash]

----

$ make docs

----



This will invoke `docs/support/scripts/make_docs.sh`, which requires

`asciidoctor` to process the doc sources and produce the HTML documentation,

emitted to _build/docs_. This script requires `ruby` and `gem` to be installed

on the system path, and will attempt to install `asciidoctor` and other related

dependencies into `$HOME/.gems` using https://bundler.io/[bundler].



Some of the dependencies require a recent version of Ruby. To build the

documentation on a system that comes with an older Ruby version (such as Ruby

2.0 on CentOS 7), it is easiest to use https://github.com/rbenv/rbenv[rbenv] to

install Ruby 2.7.



WARNING: As the default values for some configuration options differ between Mac

and Linux (e.g. file vs log block manager) and the configuration reference is

generated by running the binaries with `-help`, the documentation *MUST NOT* be

generated on Mac for publishing purposes, only for verification.



NOTE: Java API docs can only be built on Java 8 due to Javadoc compatibility

issues.



[[updating-the-site]]

=== Updating the Kudu web site documentation



To update the documentation that is integrated into the Kudu web site,

including Java and C++ client API documentation, you may run the following

command:



[source,bash]

----

$ ./docs/support/scripts/make_site.sh

----



This script will use your local Git repository to check out a shallow clone of

the 'gh-pages' branch and use `make_docs.sh` to generate the HTML documentation

for the web site. It will also build the Javadoc and Doxygen documentation.

These will be placed inside the checked-out web site, along with a tarball

containing only the generated documentation (the _docs/_ and _apidocs/_ paths

on the web site). Everything can be found in the _build/site_ subdirectory.



To build the C++ Client API you need to have Doxygen 1.8.19 or later which is

fairly new so you might need to

https://www.doxygen.nl/manual/install.html#install_src_unix[build it from

source]. To build it on RHEL/CentOS you'll also need

https://www.softwarecollections.org/en/scls/rhscl/devtoolset-8/[devtoolset] as

Doxygen uses {cpp}14 since 1.8.17.



You can proceed to commit the changes in the pages repository and send a code

review for your changes. In the future, this step may be automated whenever

changes are checked into the main Kudu repository.



After making changes to the `gh-pages` branch, follow the instructions below

when you want to deploy those changes to the live web site.



WARNING: The site *MUST NOT* be built on Mac for publishing purposes, only for

verification. See the warning in <> for details.



=== Deploying changes to the Apache Kudu web site



When the documentation is updated on the `gh-pages` branch, or when other web

site files on that branch are updated, the following procedure can be used to

deploy the changes to the official Apache Kudu web site. Committers have

permissions to publish changes to the live site.



[source,bash]

----

git checkout gh-pages

git fetch origin

git merge --ff-only origin/gh-pages

./site_tool proof        # Check for broken links (takes a long time to run)

./site_tool publish      # Generate the static HTML for the site.

cd _publish && git push  # Update the live web site.

----



NOTE: sometimes, due to glitches with the ASF gitpubsub system, a large commit,

such as a change to the docs, will not get mirrored to the live site. Adding an

empty commit and doing another git push tends to fix the problem. See the git

log for examples of people doing this in the past.



== Improving build times



=== Caching build output



The kudu build is compatible with ccache. Simply install your distro's _ccache_ package,

prepend _/usr/lib/ccache_ to your `PATH`, and watch your object files get cached. Link

times won't be affected, but you will see a noticeable improvement in compilation

times. You may also want to increase the size of your cache using "ccache -M new_size".



=== Improving linker speed



One of the major time sinks in the Kudu build is linking. GNU ld is historically

quite slow at linking large C++ applications. The alternative linker `gold` is much

better at it. It's part of the `binutils` package in modern distros (try `binutils-gold`

in older ones). To enable it, simply repoint the _/usr/bin/ld_ symlink from `ld.bfd` to

`ld.gold`.



Note that gold doesn't handle weak symbol overrides properly (see

https://sourceware.org/bugzilla/show_bug.cgi?id=16979[this bug report] for details).

As such, it cannot be used with shared objects (see below) because it'll cause

tcmalloc's alternative malloc implementation to be ignored.



=== Building Kudu with dynamic linking



Kudu can be built into shared objects, which, when used with ccache, can result in a

dramatic build time improvement in the steady state. Even after a `make clean` in the build

tree, all object files can be served from ccache. By default, `debug` and `fastdebug` will

use dynamic linking, while other build types will use static linking. To enable

dynamic linking explicitly, run:



[source,bash]

----

$ cmake -DKUDU_LINK=dynamic ../..

----



Subsequent builds will create shared objects instead of archives and use them when

linking the kudu binaries and unit tests. The full range of options for `KUDU_LINK` are

`static`, `dynamic`, and `auto`. The default is `auto` and only the first letter

matters for the purpose of matching.



NOTE: Static linking is incompatible with TSAN.



== Developing Kudu in Eclipse



Eclipse can be used as an IDE for Kudu. To generate Eclipse project files, run:



[source,bash]

----

$ mkdir -p 

$ cd 

$ rm -rf CMakeCache.txt CMakeFiles/

$ cmake -G "Eclipse CDT4 - Unix Makefiles" -DCMAKE_CXX_COMPILER_ARG1=-std=c++17 

----



When the Eclipse generator is run in a subdirectory of the source tree, the

resulting project is incomplete. That's why it's recommended to use a directory

that's a sibling to the source tree. See [1] for more details.



It's critical that _CMakeCache.txt_ be removed prior to running the generator,

otherwise the extra Eclipse generator logic (the CMakeFindEclipseCDT4.make module)

won't run and standard system includes will be missing from the generated project.



Thanks to [2], the Eclipse generator ignores the `-std=c++17` definition and we must

add it manually on the command line via `CMAKE_CXX_COMPILER_ARG1`.



By default, the Eclipse CDT indexer will index everything under the _kudu/_

source tree. It tends to choke on certain complicated source files within

_thirdparty_. In CDT 8.7.0, the indexer will generate so many errors that it'll

exit early, causing many spurious syntax errors to be highlighted. In older

versions of CDT, it'll spin forever.



Either way, these complicated source files must be excluded from indexing. To do

this, right click on the project in the Project Explorer and select Properties. In

the dialog box, select "C/C++ Project Paths", select the Source tab, highlight

"Exclusion filter: (None)", and click "Edit...". In the new dialog box, click

"Add Multiple...". Select every subdirectory inside _thirdparty_ except _installed_.

Click OK all the way out and rebuild the project index by right clicking the project

in the Project Explorer and selecting Index -> Rebuild.



With this exclusion, the only false positives (shown as "red squigglies") that

CDT presents appear to be in atomicops functions (`NoBarrier_CompareAndSwap` for

example).



Another way to approach enormous source code indexing in Ecplise is to get rid of

unnecessary source code in "thirdparty/src" directory right after building code

and before opening project in Eclipse. You can remove all source code except

hadoop, hive and sentry directories.

Additionally, if you encounter red squigglies in code editor due to

Eclipse's poor macro discovery, you may need to provide Eclipse with preprocessor

macros values, which it could not extract during auto-discovery.

Go to "Project Explorer" -> "Properties" -> "C/C++ General" ->

"Preprocessor Include Paths, Macros, etc" -> "Entries" tab -> Language "GNU C++" ->

Setting Entries "CDT User Setting Entries" -> button "Add"

-> choose "Preprocessor Macro" [3]



Another Eclipse annoyance stems from the "[Targets]" linked resource that Eclipse

generates for each unit test. These are probably used for building within Eclipse,

but one side effect is that nearly every source file appears in the indexer twice:

once via a target and once via the raw source file. To fix this, simply delete the

[Targets] linked resource via the Project Explorer. Doing this should have no effect

on writing code, though it may affect your ability to build from within Eclipse.



1. https://cmake.org/pipermail/cmake-developers/2011-November/014153.html

2. https://public.kitware.com/Bug/view.php?id=15102

3. https://www.eclipse.org/community/eclipse_newsletter/2013/october/article4.php



== Export Control Notice



This distribution uses cryptographic software and may be subject to export controls.

Please refer to docs/export_control.adoc for more information.