blob: 978cae3c2bce7631ef7aea7d9fcda4daa200c588 [file] [log] [blame]
# 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.
cmake_minimum_required(VERSION 2.6)
# generate CTest input files
enable_testing()
# Setting this enables compiling for assembly output. To compile to assembly:
# 1. cd into the directory containing the source file
# 2. 'make help' will list the assembly file targets (i.e. <srcfile.s>
# 3. 'make <srcfile>.s' to build the assembly for that file. The file is built
# to CMakeFiles/<currentdir>.dir/<srcfile>.s
PROJECT(ASSEMBLER)
# compiler flags that are common across debug/release builds
# -Wall: Enable all warnings.
# -Wno-sign-compare: suppress warnings for comparison between signed and unsigned
# integers
# -fno-strict-aliasing: disable optimizations that assume strict aliasing. This
# is unsafe to do if the code uses casts (which we obviously do).
# -Wno-unknown-pragmas: suppress warnings for unknown (compiler specific) pragmas
# -Wno-deprecated: gutil contains deprecated headers
# -Wno-vla: we use C99-style variable-length arrays
# -pthread: enable multithreaded malloc
# -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG: enable nanosecond precision for boost
# -fno-omit-frame-pointers: Keep frame pointer for functions in register
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall -Wno-sign-compare -Wno-unknown-pragmas -pthread")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fno-strict-aliasing -fno-omit-frame-pointer")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -std=c++14")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wno-deprecated -Wno-vla")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -DBOOST_SYSTEM_NO_DEPRECATED")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -B $ENV{IMPALA_TOOLCHAIN}/binutils-$ENV{IMPALA_BINUTILS_VERSION}/bin/")
IF($ENV{USE_GOLD_LINKER} STREQUAL "true")
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -fuse-ld=gold")
ENDIF()
# On Apple we build with clang and need libstdc++ instead of libc++
if (APPLE)
SET(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -stdlib=libstdc++")
endif()
SET(CXX_COVERAGE_FLAGS "-fprofile-arcs -ftest-coverage -DCODE_COVERAGE_ENABLED")
# For any clang builds (currently only ASAN):
# -Qunused-arguments: quiet warnings about unused arguments to clang because ccache
# makes extra calls to clang which may have extra includes (-I) that are unused.
# -fcolor-diagnostics: ensure clang generates colorized output, which is necessary
# when using ccache as clang thinks it is not called from a terminal.
# -Wno-zero-as-null-pointer-constant: We are slowly moving towards the use of nullptr,
# but till we switch to it completely, we will ignore the warnings due to use of
# NULL as a null pointer constant.
# -Wno-c++17-extensions: ignore warnings caused due to the use of [[nodiscard]]
# attribute which our current compiler does not support but is used in conjunction
# with WARN_UNUSED_RESULT with our current toolchain to be effective.
# -Wno-inconsistent-missing-destructor-override: ignore warnings to mark virtual
# destructors with 'override' which is enforced by clang by not recommended by c++
# core guidelines (read C.128).
SET(CXX_CLANG_FLAGS "-Qunused-arguments -fcolor-diagnostics -Wno-unused-local-typedef")
SET(CXX_CLANG_FLAGS "${CXX_CLANG_FLAGS} -Wno-zero-as-null-pointer-constant")
SET(CXX_CLANG_FLAGS "${CXX_CLANG_FLAGS} -Wno-c++17-extensions")
SET(CXX_CLANG_FLAGS "${CXX_CLANG_FLAGS} -Wno-inconsistent-missing-destructor-override")
SET(CXX_CLANG_FLAGS "${CXX_CLANG_FLAGS} -Wno-return-type-c-linkage")
# For any gcc builds:
# -g: Enable symbols for profiler tools
# -Wno-unused-local-typedefs: Do not warn for local typedefs that are unused.
SET(CXX_GCC_FLAGS "-g -Wno-unused-local-typedefs")
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0)
# We need to add additional arguments for GCC 7+. We go down this branch if building
# with a non-GCC compiler of version 7+, but in that case CXX_GCC_FLAGS is not used,
# so it is inconsequential. TODO: IMPALA-5490: make this non-conditional when we
# upgrade GCC.
# -faligned-new: new will automatically align types. Otherwise "new Counter()" in the
# Kudu util code produces a warning (see KUDU-2094).
# TODO: -faligned-new is part of C++17, remove flag when we bump language version.
SET(CXX_GCC_FLAGS "${CXX_GCC_FLAGS} -faligned-new")
endif()
# compiler flags for different build types (run 'cmake -DCMAKE_BUILD_TYPE=<type> .')
# For CMAKE_BUILD_TYPE=Debug
# -ggdb: Enable gdb debugging
# For CMAKE_BUILD_TYPE=Release
# -O3: Enable all compiler optimizations
# -DNDEBUG: Turn off dchecks/asserts/debug only code.
#
# Debug information is stored as dwarf2 to be as compatible as possible
SET(CXX_FLAGS_DEBUG "${CXX_GCC_FLAGS} -ggdb -gdwarf-2")
# -Werror: compile warnings should be errors when using the toolchain compiler.
# Enabled for DEBUG, ASAN, TSAN and UBSAN builds which are built pre-commit.
SET(CXX_FLAGS_DEBUG "${CXX_FLAGS_DEBUG} -Werror")
SET(CXX_FLAGS_RELEASE "${CXX_GCC_FLAGS} -O3 -DNDEBUG -gdwarf-2")
SET(CXX_FLAGS_ADDRESS_SANITIZER
"${CXX_CLANG_FLAGS} -Werror -O1 -g -fsanitize=address -fno-omit-frame-pointer -DADDRESS_SANITIZER")
# Set the flags to the undefined behavior sanitizer, also known as "ubsan"
# Turn on sanitizer and debug symbols to get stack traces:
SET(CXX_FLAGS_UBSAN "${CXX_CLANG_FLAGS} -Werror -ggdb3 -fno-omit-frame-pointer -fsanitize=undefined")
# Set preprocessor macros to facilitate initialization the relevant configuration.
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -DUNDEFINED_SANITIZER")
# Calling getenv() in __ubsan_default_options doesn't work, likely because of
# initialization ordering. We need to double-quote to create a macro that expands
# to a string-literal.
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -DUNDEFINED_SANITIZER_SUPPRESSIONS=\\\"$ENV{IMPALA_HOME}/bin/ubsan-suppressions.txt\\\"")
# Add flags to enable symbol resolution in the stack traces:
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -rtlib=compiler-rt -lgcc_s")
# Ignore a number of noisy errors with too many false positives:
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -fno-sanitize=alignment,function,vptr,float-divide-by-zero,float-cast-overflow")
# Don't enforce wrapped signed integer arithmetic so that the sanitizer actually sees
# undefined wrapping:
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -fno-wrapv")
# To ease debugging, turn off all optimizations:
SET(CXX_FLAGS_UBSAN "${CXX_FLAGS_UBSAN} -O0")
# Set the flags to the thread sanitizer, also known as "tsan"
# Turn on sanitizer and debug symbols to get stack traces:
SET(CXX_FLAGS_TSAN "${CXX_CLANG_FLAGS} -Werror -O1 -ggdb3 -fno-omit-frame-pointer")
SET(CXX_FLAGS_TSAN "${CXX_FLAGS_TSAN} -fsanitize=thread -DTHREAD_SANITIZER")
SET(CXX_FLAGS_TIDY "${CXX_CLANG_FLAGS}")
# Catching unused variables requires an optimization level greater than 0
SET(CXX_FLAGS_TIDY "${CXX_FLAGS_TIDY} -O1")
# Ignore assert() and DCHECK() to avoid dead code errors on "DCHECK(false); return
# nullptr" in impossible default switch/case statements.
SET(CXX_FLAGS_TIDY "${CXX_FLAGS_TIDY} -DNDEBUG")
# Turn all warnings back on. Some will be ignored via .clang-tidy's "Checks" value, but
# this allows different "Checks" settings to be used in different clang-tidy runs without
# recompiling.
SET(CXX_FLAGS_TIDY "${CXX_FLAGS_TIDY} -Wall -W -Weverything")
# The Tidy build is so verbose (becasue of -Weverything) that it is unlikely to be viewed
# in a terminal and most likely will be redirecto to less, a log file, or /dev/null. In
# those places color codes just make the output harder to read.
SET(CXX_FLAGS_TIDY "${CXX_FLAGS_TIDY} -fno-color-diagnostics")
# Set compile flags based on the build type.
if ("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
SET(CMAKE_CXX_FLAGS ${CXX_FLAGS_DEBUG})
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
SET(CMAKE_CXX_FLAGS ${CXX_FLAGS_RELEASE})
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "ADDRESS_SANITIZER")
SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_ADDRESS_SANITIZER}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "TIDY")
SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_TIDY}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN")
SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_UBSAN}")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN_FULL")
SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_UBSAN}")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNDEFINED_SANITIZER_FULL")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
SET(CMAKE_CXX_FLAGS "${CXX_FLAGS_TSAN}")
else()
message(FATAL_ERROR "Unknown build type: ${CMAKE_BUILD_TYPE}")
endif()
if (ENABLE_CODE_COVERAGE)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CXX_COVERAGE_FLAGS}")
endif()
# Add flags that are common across build types
# - fverbose-asm creates better annotated assembly. This doesn't seem to affect
# when building the binary.
# LLMV_CFLAGS - Adding llvm compile flags
SET(CMAKE_CXX_FLAGS "${CXX_COMMON_FLAGS} ${CMAKE_CXX_FLAGS}")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fverbose-asm")
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LLVM_CFLAGS}")
# Use ccache when found and not explicitly disabled by setting the DISABLE_CCACHE envvar.
find_program(CCACHE ccache)
set(RULE_LAUNCH_PREFIX)
if (CCACHE AND NOT DEFINED ENV{DISABLE_CCACHE})
set(RULE_LAUNCH_PREFIX ccache)
if ("${CMAKE_BUILD_TYPE}" STREQUAL "ADDRESS_SANITIZER"
OR "${CMAKE_BUILD_TYPE}" STREQUAL "TIDY"
OR "${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN"
OR "${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN_FULL"
OR "${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
# Need to set CCACHE_CPP so that ccache calls clang with the original source file for
# both preprocessing and compilation. Otherwise, ccache will use clang to preprocess
# the file and then call clang with the preprocessed output if not cached. However,
# the preprocessed output from clang may contain code (e.g. from macro expansions)
# that generates compilation warnings that would not be reported if compiling the
# original source directly with clang.
SET(ENV{CCACHE_CPP} YES)
endif()
endif()
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${RULE_LAUNCH_PREFIX})
set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ${RULE_LAUNCH_PREFIX})
# Thrift requires these definitions for some types that we use
add_definitions(-DHAVE_INTTYPES_H -DHAVE_NETINET_IN_H -DHAVE_NETDB_H)
# Kudu flags. 1. Enable non KUDU_* prefixes for status macros to allow Kudu code to
# compile without changing the macro. 2. Enable full support for all backing types of
# kudu::Slices. 3. Don't include stubs.h
add_definitions(-DKUDU_HEADERS_USE_SHORT_STATUS_MACROS -DKUDU_HEADERS_USE_RICH_SLICE
-DKUDU_HEADERS_NO_STUBS)
# Set clang flags for cross-compiling to IR.
# IR_COMPILE is #defined for the cross compile to remove code that bloats the IR.
# We enable basic optimizations (-O1) to reduce the IR size and speed up runtime JIT.
# Empirically, the runtime JIT produces slightly better code when starting with IR that
# was optimized at -O1. Higher optimization levels tend to bloat the code.
# -Wno-deprecated: gutil contains deprecated headers
# -Wno-return-type-c-linkage: UDFs return C++ classes but use C linkage to prevent
# mangling
# -DBOOST_NO_EXCEPTIONS: call a custom error handler for exceptions in codegen'd code.
set(CLANG_IR_CXX_FLAGS "-emit-llvm" "-c" "-std=c++14" "-DIR_COMPILE" "-DHAVE_INTTYPES_H"
"-DHAVE_NETINET_IN_H" "-DBOOST_DATE_TIME_POSIX_TIME_STD_CONFIG" "-DBOOST_NO_EXCEPTIONS"
"-fcolor-diagnostics" "-Wno-deprecated" "-Wno-return-type-c-linkage" "-O1")
# -Werror: compile warnings should be errors when using the toolchain compiler.
set(CLANG_IR_CXX_FLAGS "${CLANG_IR_CXX_FLAGS}" "-Werror")
if ("${CMAKE_BUILD_TYPE}" STREQUAL "ADDRESS_SANITIZER")
SET(CLANG_IR_CXX_FLAGS "${CLANG_IR_CXX_FLAGS}" "-DADDRESS_SANITIZER")
elseif ("${CMAKE_BUILD_TYPE}" STREQUAL "RELEASE")
SET(CLANG_IR_CXX_FLAGS "${CLANG_IR_CXX_FLAGS}" "-DNDEBUG")
endif()
if ("${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN_FULL")
set(CLANG_IR_CXX_FLAGS "${CLANG_IR_CXX_FLAGS}" "-DUNDEFINED_SANITIZER"
"-fno-omit-frame-pointer" "-fsanitize=undefined" "-fno-wrapv" "-ggdb3"
"-fno-sanitize=alignment,function,vptr,float-divide-by-zero,float-cast-overflow"
"-DUNDEFINED_SANITIZER_SUPPRESSIONS=\\\"$ENV{IMPALA_HOME}/bin/ubsan-suppressions.txt\\\"")
endif()
IF($ENV{ENABLE_IMPALA_IR_DEBUG_INFO} STREQUAL "true")
# -g: emit debug symbols in IR. These increase IR size and memory overhead of LLVM, but
# are useful for debugging codegened code and interpreting codegen disassembly
# dumps.
SET(CLANG_IR_CXX_FLAGS "${CLANG_IR_CXX_FLAGS}" "-g")
endif()
# Flags to pass to LLVM's opt to further optimize cross-compiled IR.
# -inline: inline with low threshold to get rid of trivial accessor functions.
set(LLVM_OPT_IR_FLAGS "-inline" "-inlinehint-threshold=10" "-inline-threshold=10")
# Additional compile flags that will hide symbols by default, e.g. for building
# UDFs. We have both a concatenated string version and a list version for convenience,
# depending on what is needed in the context.
set(HIDE_SYMBOLS "-fvisibility=hidden -fvisibility-inlines-hidden")
set(HIDE_SYMBOLS_ARGS "${HIDE_SYMBOLS_STRING}")
separate_arguments(HIDE_SYMBOLS_ARGS)
# setup doc generation with Doxygen
find_package(Doxygen)
if (DOXYGEN_FOUND)
set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/build/docs)
# Possible to not input the subdirs one by one?
set(CMAKE_DOXYGEN_INPUT
${CMAKE_SOURCE_DIR}/be/src
${CMAKE_SOURCE_DIR}/be/src/catalog/
${CMAKE_SOURCE_DIR}/be/src/common/
${CMAKE_SOURCE_DIR}/be/src/exec/
${CMAKE_SOURCE_DIR}/be/src/exprs/
${CMAKE_SOURCE_DIR}/be/src/runtime/
${CMAKE_SOURCE_DIR}/be/src/scheduling/
${CMAKE_SOURCE_DIR}/be/src/service/
${CMAKE_SOURCE_DIR}/be/src/statestore/
${CMAKE_SOURCE_DIR}/be/src/testutil/
${CMAKE_SOURCE_DIR}/be/src/thrift/
${CMAKE_SOURCE_DIR}/be/src/util/
${CMAKE_SOURCE_DIR}/be/src/transport/
)
# CMake appends using ';'. doxygen wants spaces
string(REPLACE ";" " " DOXYGEN_INPUT "${CMAKE_DOXYGEN_INPUT}")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/.impala.doxy
${CMAKE_CURRENT_SOURCE_DIR}/build/config/.impala.doxy)
file(MAKE_DIRECTORY ${DOXYGEN_OUTPUT_DIR})
add_custom_target(docs
COMMAND ${CMAKE_COMMAND} -E echo_append "Building Docs..."
COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/build/config/.impala.doxy
)
else (DOXYGEN_FOUND)
MESSAGE(STATUS "WARNING: Doxygen not found - Docs will not be created")
endif(DOXYGEN_FOUND)
# resolve "#include "<subdir>/<name>.h"
include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/src)
# resolve includes of generated code
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/generated-sources)
set(CLANG_INCLUDE_FLAGS)
# Ensure that clang uses the gcc toolchain headers.
set(CLANG_BASE_FLAGS --gcc-toolchain=${GCC_ROOT})
set(CLANG_INCLUDE_FLAGS ${CLANG_BASE_FLAGS})
set(CLANG_INCLUDE_FLAGS
${CLANG_INCLUDE_FLAGS}
"-I${CMAKE_CURRENT_SOURCE_DIR}/src"
"-I${CMAKE_CURRENT_SOURCE_DIR}/generated-sources"
"-I${THRIFT_INCLUDE_DIR}"
"-I${SQUEASEL_INCLUDE_DIR}"
"-I${GLOG_INCLUDE_DIR}"
"-I${GFLAGS_INCLUDE_DIR}"
"-I${GTEST_INCLUDE_DIR}"
"-I${RAPIDJSON_INCLUDE_DIR}"
"-I${AVRO_INCLUDE_DIR}"
"-I${ORC_INCLUDE_DIR}"
# Include Boost as a system directory to suppress warnings from headers.
"-isystem${BOOST_INCLUDEDIR}"
# Required so that jni.h can be found during Clang compilation
"-I${JAVA_INCLUDE_PATH}"
"-I${JAVA_INCLUDE_PATH2}"
"-I${RE2_INCLUDE_DIR}"
"-I${SASL_INCLUDE_DIR}"
"-I${BZIP2_INCLUDE_DIR}"
"-I${ZLIB_INCLUDE_DIR}"
"-I${OPENSSL_INCLUDE_DIR}"
"-I${LDAP_INCLUDE_DIR}"
"-I${PROTOBUF_INCLUDE_DIR}"
"-I${CCTZ_INCLUDE_DIR}"
)
# allow linking of static libs into dynamic lib
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
# set compile output directory
if ("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG" OR
"${CMAKE_BUILD_TYPE}" STREQUAL "ADDRESS_SANITIZER" OR
"${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN" OR
"${CMAKE_BUILD_TYPE}" STREQUAL "UBSAN_FULL" OR
"${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
set(BUILD_OUTPUT_ROOT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/build/debug/")
else()
set(BUILD_OUTPUT_ROOT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/build/release/")
endif()
# Create a latest link so that scripts can pick up the correct build automatically
FILE(MAKE_DIRECTORY ${BUILD_OUTPUT_ROOT_DIRECTORY})
if (NOT APPLE)
set(MORE_ARGS "-T")
endif()
EXECUTE_PROCESS(COMMAND ln ${MORE_ARGS} -sf ${BUILD_OUTPUT_ROOT_DIRECTORY}
${CMAKE_CURRENT_SOURCE_DIR}/build/latest)
# Determine what functions are available on the current platform.
INCLUDE(CheckFunctionExists)
CHECK_FUNCTION_EXISTS(sched_getcpu HAVE_SCHED_GETCPU)
CHECK_FUNCTION_EXISTS(pipe2 HAVE_PIPE2)
CHECK_FUNCTION_EXISTS(sync_file_range HAVE_SYNC_FILE_RANGE)
# linux/fs.h defines HAVE_FALLOCATE whether or not the function is available,
# which is why we use IMPALA_HAVE_FALLOCATE here.
CHECK_FUNCTION_EXISTS(fallocate IMPALA_HAVE_FALLOCATE)
CHECK_FUNCTION_EXISTS(preadv HAVE_PREADV)
INCLUDE(CheckIncludeFiles)
CHECK_INCLUDE_FILES(linux/magic.h HAVE_MAGIC_H)
# Used to check if we're using krb-1.6 or lower.
CHECK_LIBRARY_EXISTS("krb5" krb5_get_init_creds_opt_set_fast_ccache_name
${KERBEROS_LIBRARY} HAVE_KRB5_GET_INIT_CREDS_OPT_SET_FAST_CCACHE_NAME)
# This is a list of impala library dependencies. Individual libraries
# must not specify library dependencies in their own CMakeLists.txt file.
# Enclose the impala libraries in -Wl,--start-group and -Wl,--end-group
# to resolve cyclic dependencies. As long as those flags are given,
# the order in which impala libraries are listed below does not matter.
# Note: The ld documentation discourages auto-resolving cyclic dependencies
# for performance reasons.
if (NOT APPLE)
# When compiling on Mac with clang using these linker flags are undefined and Clang on
# Mac will abort on unknown compiler or linker flags. In the long-term we should
# move away from using these flags to have a coherent build on OS X and Linux.
set(WL_START_GROUP "-Wl,--start-group")
set(WL_END_GROUP "-Wl,--end-group")
endif()
set (IMPALA_LIBS
BufferPool
Catalog
CodeGen
Common
Parquet
Exec
Exprs
GlobalFlags
histogram_proto
ImpalaThrift
Io
kudu_util
krpc
Rpc
rpc_header_proto
rpc_introspection_proto
pb_util_proto
Runtime
Scheduling
security
Service
Statestore
TestUtil
ThriftSaslTransport
token_proto
Udf
Util
)
set (IMPALA_LINK_LIBS
${WL_START_GROUP}
${IMPALA_LIBS}
${WL_END_GROUP}
)
# Backend tests originally produced a single executable for each backend c++ test file.
# Since these executables linked in all of the libraries, each test is very large
# (100s of MB) and requires considerable link time. To address this, tests can now
# be linked into a unified test executable that contains tests from many backend
# c++ test files. See the ADD_UNIFIED_BE_TEST and ADD_UNIFIED_LSAN_BE_TEST
# macros below. The original mode of producing a standalone executable is still
# available via the ADD_BE_TEST and ADD_LSAN_BE_TEST macros.
#
# To make a unified test executable, the backend tests need to be in their own libraries.
# The main function is provided by the unified main c++ file. None of the test c++ files
# has a main function. Normal dependency resolution would not include any of the tests
# in any executable, as no function references them. Force the unified test executable
# to include the tests by using "--whole-archive".
set(WL_WHOLE_ARCHIVE "-Wl,--whole-archive")
set(WL_NO_WHOLE_ARCHIVE "-Wl,--no-whole-archive")
set (UNIFIED_TEST_LIBS
BufferPoolTests
CatalogTests
CodeGenTests
CommonTests
ExecTests
ExprsTests
GUtilTests
IoTests
ParquetTests
RpcTests
RuntimeTests
SchedulingTests
ServiceTests
UtilTests
)
set (UNIFIED_TEST_LINK_LIBS
${WL_START_GROUP}
${WL_WHOLE_ARCHIVE}
${UNIFIED_TEST_LIBS}
${WL_NO_WHOLE_ARCHIVE}
${IMPALA_LIBS}
${WL_END_GROUP}
)
# If using dynamic linking, -Wl does not have any effect (it's only for .a files). So we
# need to add these redundant dependencies to resolve the circular references in our
# libraries when dynamic linking is enabled.
if (BUILD_SHARED_LIBS)
set (IMPALA_LINK_LIBS ${IMPALA_LINK_LIBS}
BufferPool
Io
Runtime
Parquet
Exec
CodeGen
Exprs
Rpc
Service
security
Statestore
Scheduling
Catalog
ImpalaThrift
GlobalFlags
Common
Udf
)
endif ()
set (IMPALA_DEPENDENCIES
snappy
lz4
zstd
re2
${Boost_LIBRARIES}
${LLVM_MODULE_LIBS}
thrift
cyrus_sasl
ldap
lber
ThriftSaslTransport
openssl_ssl
openssl_crypto
crcutil
gutil
glog
gflags
krb5
libev
libunwind
pprof
breakpad_client
hdfs
zlib
bzip2
avro
orc
java_jvm
kudu_client
cctz)
# Add all external dependencies. They should come after the impala libs.
set (IMPALA_LINK_LIBS ${IMPALA_LINK_LIBS}
${IMPALA_DEPENDENCIES}
-lrt
-ldl # Needed for LLVM
)
# Add external dependencies for backend tests
set (UNIFIED_TEST_LINK_LIBS ${UNIFIED_TEST_LINK_LIBS}
${IMPALA_DEPENDENCIES}
-lrt
-ldl # Needed for LLVM
)
if (ENABLE_CODE_COVERAGE)
set(IMPALA_LINK_LIBS ${IMPALA_LINK_LIBS} -lgcov)
set(UNIFIED_TEST_LINK_LIBS ${UNIFIED_TEST_LINK_LIBS} -lgcov)
endif()
# The above link list does not include tcmalloc. This is because the Impala JVM support
# libraries (libfesupport, libloggingsupport) cannot use tcmalloc in all cases. When they
# are started up by the FE (for tests) the jvm has already made allocations before
# tcmalloc can be loaded. In all other binaries, we can use tcmalloc except the address
# sanitizer build. Address sanitizer is incompatible with tcmalloc (they both intercept
# malloc/free)
set (IMPALA_LINK_LIBS_NO_TCMALLOC ${IMPALA_LINK_LIBS})
if (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "ADDRESS_SANITIZER" AND
NOT "${CMAKE_BUILD_TYPE}" STREQUAL "TSAN")
set (IMPALA_LINK_LIBS ${IMPALA_LINK_LIBS} tcmallocstatic)
set (UNIFIED_TEST_LINK_LIBS ${UNIFIED_TEST_LINK_LIBS} tcmallocstatic)
endif()
# When we link statically, we need to replace the static libhdfs.a with the dynamic
# version otherwise the dynamic support libraries will pickup the static libhdfs.a
# library. The result will not compile as libhdfs.a is not compiled with -fpic. The same
# is true for other system dependencies that we don't have control over.
set(IMPALA_LINK_LIBS_DYNAMIC_TARGETS ${IMPALA_LINK_LIBS_NO_TCMALLOC})
list(REMOVE_ITEM IMPALA_LINK_LIBS_DYNAMIC_TARGETS hdfs)
set(IMPALA_LINK_LIBS_DYNAMIC_TARGETS ${IMPALA_LINK_LIBS_DYNAMIC_TARGETS}
${HDFS_SHARED_LIB})
# Link libs for test executables. Although not all tests need all libs,
# the build time for the tests is rather small and not worth the trouble.
# TODO: build time for tests is no longer small, but our dependencies are now very
# complicated and hard to isolate
set (IMPALA_TEST_LINK_LIBS ${IMPALA_LINK_LIBS} gtest)
set (UNIFIED_TEST_LINK_LIBS ${UNIFIED_TEST_LINK_LIBS} gtest)
MESSAGE(STATUS "Compiler Flags: ${CMAKE_CXX_FLAGS}")
if (CMAKE_DEBUG)
MESSAGE(STATUS "Linker Libs: ${IMPALA_LINK_LIBS}")
endif()
set(LLVM_IR_OUTPUT_DIRECTORY "${CMAKE_SOURCE_DIR}/llvm-ir")
file(MAKE_DIRECTORY ${LLVM_IR_OUTPUT_DIRECTORY})
# Add custom target to only build the backend tests
# Note: this specifies "ALL" so it builds if running "make" with no arguments. This is
# necessary due to the non-executable targets (i.e. generating backend test scripts)
# that run for the unified backend tests.
add_custom_target(be-test ALL)
# Add custom target to build unified backend tests
add_custom_target(unified-be-test)
# Add custom target to build the unified backend test executable
add_custom_target(unified-be-test-executable)
# Variable to use to aggregate all of the filter patterns, joined by ":"
set_property(GLOBAL PROPERTY AGG_UNIFIED_FILTER_PATTERN)
# Utility CMake functions for specifying tests and benchmarks
# ADD_BE_TEST: This function adds a backend test with its own executable. The associated
# c++ file must have its own main() function.
FUNCTION(ADD_BE_TEST TEST_NAME)
# This gets the directory where the test is from (e.g. 'exprs' or 'runtime')
file(RELATIVE_PATH DIR_NAME "${CMAKE_SOURCE_DIR}/be/src/" ${CMAKE_CURRENT_SOURCE_DIR})
ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
TARGET_LINK_LIBRARIES(${TEST_NAME} ${IMPALA_TEST_LINK_LIBS})
set(CMAKE_EXE_LINKER_FLAGS "--start-group")
ADD_TEST(${TEST_NAME} "${BUILD_OUTPUT_ROOT_DIRECTORY}/${DIR_NAME}/${TEST_NAME}"
-log_dir=$ENV{IMPALA_BE_TEST_LOGS_DIR})
ADD_DEPENDENCIES(be-test ${TEST_NAME})
ENDFUNCTION()
# ADD_UNIFIED_BE_TEST: This function adds a backend test that is part of the unified
# backend executable. This creates an executable script that runs the unified executable
# with appropriate args to run the subset of tests identified by "TEST_FILTER_PATTERN".
# See the documentation for --gtest_filter for examples of filter patterns.
FUNCTION(ADD_UNIFIED_BE_TEST TEST_NAME TEST_FILTER_PATTERN)
# This gets the directory where the test is from (e.g. 'exprs' or 'runtime')
file(RELATIVE_PATH DIR_NAME "${CMAKE_SOURCE_DIR}/be/src/" ${CMAKE_CURRENT_SOURCE_DIR})
add_custom_target(${TEST_NAME} "${CMAKE_SOURCE_DIR}/bin/gen-backend-test-script.py"
"--test_script_output" "${BUILD_OUTPUT_ROOT_DIRECTORY}/${DIR_NAME}/${TEST_NAME}"
"--gtest_filter" ${TEST_FILTER_PATTERN})
# Incorporate this TEST_FILTER_PATTERN into the aggregate list of filter patterns
get_property(tmp GLOBAL PROPERTY AGG_UNIFIED_FILTER_PATTERN)
set(tmp "${TEST_FILTER_PATTERN}:${tmp}")
set_property(GLOBAL PROPERTY AGG_UNIFIED_FILTER_PATTERN "${tmp}")
ADD_TEST(NAME ${TEST_NAME}
COMMAND "${BUILD_OUTPUT_ROOT_DIRECTORY}/${DIR_NAME}/${TEST_NAME}"
-log_dir=$ENV{IMPALA_BE_TEST_LOGS_DIR})
ADD_DEPENDENCIES(unified-be-test ${TEST_NAME})
ADD_DEPENDENCIES(${TEST_NAME} unified-be-test-validated-executable)
ENDFUNCTION()
FUNCTION(ENABLE_LSAN_FOR_TEST TEST_NAME)
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES ENVIRONMENT
"ASAN_OPTIONS=handle_segv=0 detect_leaks=1 allocator_may_return_null=1")
SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES ENVIRONMENT
"LSAN_OPTIONS=suppressions=${CMAKE_SOURCE_DIR}/bin/lsan-suppressions.txt")
ENDFUNCTION()
# ADD_BE_LSAN_TEST: Same as ADD_BE_TEST, but also enable LeakSanitizer.
# TODO: IMPALA-2746: we should make this the default.
FUNCTION(ADD_BE_LSAN_TEST TEST_NAME)
ADD_BE_TEST(${TEST_NAME})
ENABLE_LSAN_FOR_TEST(${TEST_NAME})
ENDFUNCTION()
# ADD_UNIFIED_BE_LSAN_TEST: Same as ADD_UNIFIED_BE_TEST, but also enable LeakSanitizer.
# TODO: IMPALA_2746: we should make this the default.
FUNCTION(ADD_UNIFIED_BE_LSAN_TEST TEST_NAME TEST_FILTER_PATTERN)
ADD_UNIFIED_BE_TEST(${TEST_NAME} ${TEST_FILTER_PATTERN})
ENABLE_LSAN_FOR_TEST(${TEST_NAME})
ENDFUNCTION()
# Similar utility function for tests that use the UDF SDK
FUNCTION(ADD_UDF_TEST TEST_NAME)
# This gets the directory where the test is from (e.g. 'exprs' or 'runtime')
get_filename_component(DIR_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME)
ADD_EXECUTABLE(${TEST_NAME} ${TEST_NAME}.cc)
# Set ImpalaUdf as the first link library for UDF tests. This will cause its test
# definitions to be linked instead of subsequent non-test definitions. Otherwise the
# test definitions of MemTracker, etc. will be used in the udf.cc compilation unit, but
# the Runtime method implementations will be linked. See IMPALA-3132.
TARGET_LINK_LIBRARIES(${TEST_NAME} ImpalaUdf ${IMPALA_TEST_LINK_LIBS})
set(CMAKE_EXE_LINKER_FLAGS "--start-group")
ADD_TEST(${TEST_NAME} "${BUILD_OUTPUT_ROOT_DIRECTORY}/${DIR_NAME}/${TEST_NAME}"
-log_dir=$ENV{IMPALA_BE_TEST_LOGS_DIR})
ADD_DEPENDENCIES(be-test ${TEST_NAME})
ENABLE_LSAN_FOR_TEST(${TEST_NAME})
ENDFUNCTION()
# Function to generate rule to cross compile a source file to an IR module.
# This should be called with the .cc src file and it will generate a
# src-file-ir target that can be built.
# e.g. COMPILE_TO_IR(test.cc) generates the "test-ir" make target.
# Note: this is duplicated in udf_samples/CMakeLists.txt
function(COMPILE_TO_IR SRC_FILE)
get_filename_component(BASE_NAME ${SRC_FILE} NAME_WE)
set(OUTPUT_FILE "${LIBRARY_OUTPUT_PATH}/${BASE_NAME}.ll")
add_custom_command(
OUTPUT ${OUTPUT_FILE}
COMMAND ${LLVM_CLANG_EXECUTABLE} ${CLANG_IR_CXX_FLAGS} ${HIDE_SYMBOLS_ARGS}
${CLANG_INCLUDE_FLAGS} ${SRC_FILE} -o ${OUTPUT_FILE}
DEPENDS ${SRC_FILE})
add_custom_target(${BASE_NAME}-ir ALL DEPENDS ${OUTPUT_FILE})
endfunction(COMPILE_TO_IR)
# Gutil is a little bit special
add_subdirectory(src/gutil)
# compile these subdirs using their own CMakeLists.txt
add_subdirectory(src/catalog)
add_subdirectory(src/codegen)
add_subdirectory(src/common)
add_subdirectory(src/exec)
add_subdirectory(src/exprs)
add_subdirectory(src/kudu/security)
add_subdirectory(src/kudu/rpc)
add_subdirectory(src/kudu/util)
add_subdirectory(src/runtime)
add_subdirectory(src/scheduling)
add_subdirectory(src/statestore)
add_subdirectory(src/service)
add_subdirectory(src/testutil)
add_subdirectory(src/rpc)
add_subdirectory(src/udf)
add_subdirectory(src/udf_samples)
add_subdirectory(src/util)
add_subdirectory(src/transport)
add_subdirectory(src/benchmarks)
add_subdirectory(src/experiments)
# Thrift generated files have unused variables. Ignore those compiler
# warnings by adding this flag. Note: impala subdirectories should be
# added *before* this so we can fix our issues.
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable")
add_subdirectory(generated-sources/gen-cpp)
link_directories(
${CMAKE_CURRENT_SOURCE_DIR}/build/catalog
${CMAKE_CURRENT_SOURCE_DIR}/build/common
${CMAKE_CURRENT_SOURCE_DIR}/build/exec
${CMAKE_CURRENT_SOURCE_DIR}/build/exprs
${CMAKE_CURRENT_SOURCE_DIR}/build/rpc
${CMAKE_CURRENT_SOURCE_DIR}/build/runtime
${CMAKE_CURRENT_SOURCE_DIR}/build/statestore
${CMAKE_CURRENT_SOURCE_DIR}/build/service
${CMAKE_CURRENT_SOURCE_DIR}/build/testutil
${CMAKE_CURRENT_SOURCE_DIR}/build/util
${CMAKE_CURRENT_SOURCE_DIR}/build/transport
)
# Add custom target to validate the unified backend test executable and test match
# patterns. At this point, all filter patterns have been aggregated from the individual
# ADD_UNIFIED_BE_TEST calls into AGG_UNIFIED_FILTER_PATTERN.
get_property(TOTAL_UNIFIED_FILTER_PATTERN GLOBAL PROPERTY AGG_UNIFIED_FILTER_PATTERN)
add_custom_target(unified-be-test-validated-executable
"${CMAKE_CURRENT_SOURCE_DIR}/../bin/validate-unified-backend-test-filters.py"
"-f" "${TOTAL_UNIFIED_FILTER_PATTERN}"
"-b" "${BUILD_OUTPUT_ROOT_DIRECTORY}/service/unifiedbetests")
ADD_DEPENDENCIES(be-test unified-be-test)
ADD_DEPENDENCIES(unified-be-test unified-be-test-validated-executable)
ADD_DEPENDENCIES(unified-be-test-validated-executable unified-be-test-executable)
# only generate statically linked libs and executables
set(BUILD_SHARED_LIBS OFF)
# where to put generated libraries
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${BUILD_OUTPUT_ROOT_DIRECTORY}")
set(ARCHIVE_OUTPUT_DIRECTORY "${BUILD_OUTPUT_ROOT_DIRECTORY}")
# where to put generated binaries
set(EXECUTABLE_OUTPUT_PATH "${BUILD_OUTPUT_ROOT_DIRECTORY}")