| # 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.8.6) |
| project (QUICKSTEP) |
| |
| set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake") |
| |
| include(CheckCCompilerFlag) |
| include(CheckCXXCompilerFlag) |
| include(CheckCXXSourceCompiles) |
| include(QsProtobufGenerateCpp) |
| |
| if(NOT CMAKE_BUILD_TYPE) |
| set(CMAKE_BUILD_TYPE "RelWithDebInfo" CACHE STRING |
| "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) |
| endif(NOT CMAKE_BUILD_TYPE) |
| |
| if (WIN32) |
| # Make Windows compilers shut up about using standard libc functions. |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS _CRT_SECURE_NO_WARNINGS |
| ) |
| endif() |
| |
| include(CheckIncludeFiles) |
| check_include_files( |
| "termios.h;unistd.h;stdlib.h;stdio.h;errno.h;string.h;stdlib.h;ctype.h;sys/types.h;sys/ioctl.h;unistd.h" |
| HAVE_LINENOISE_HEADERS) |
| if (HAVE_LINENOISE_HEADERS) |
| option(USE_LINENOISE "Use linenoise command-line editing library" ON) |
| else() |
| option(USE_LINENOISE "Use linenoise command-line editing library" OFF) |
| endif() |
| |
| check_include_files("hdfs/hdfs.h" HAVE_LIBHDFS3_HEADERS) |
| if (HAVE_LIBHDFS3_HEADERS) |
| option(ENABLE_HDFS "Enable HDFS FileManager" ON) |
| else() |
| option(ENABLE_HDFS "Enable HDFS FileManager" OFF) |
| endif() |
| |
| if (UNIX AND NOT CYGWIN AND NOT APPLE) |
| option(USE_TCMALLOC "Use tcmalloc (Google's thread-cacheing malloc) instead of system-provided malloc" ON) |
| else() |
| option(USE_TCMALLOC "Use tcmalloc (Google's thread-cacheing malloc) instead of system-provided malloc" OFF) |
| endif() |
| |
| # Option to enable/disable LTO. |
| option(ENABLE_LTO "Enable LTO (Link Time Optimization), if the compiler supports it." OFF) |
| |
| set(VECTOR_COPY_ELISION_MSG_LIST |
| "This options controls whether extra code paths for vectorized evaluation " |
| "of expressions and predicates directly on values inside storage blocks " |
| "without copying into ColumnVectors is enabled. This may improve " |
| "performance, but causes a combinatorial explosion of templated code to " |
| "be compiled, which may cause very long builds (especially in Release " |
| "mode) and very large executables (especially in Debug mode). The " |
| "valid settings for this option are, in order of increasing code paths: " |
| "none (attribute values are always copied into ColumnVectors before " |
| "computing expressions on them), selection (copies are elided for " |
| "single-relation SELECT operations), join (copies are also elided for " |
| "expressions in the output of hash joins, but binary expressions will " |
| "only elide a copy on one side, not both), and joinwithbinaryexpressions " |
| "(copies are elided for both sides of a binary expression over a join).") |
| string(REPLACE ";" "" VECTOR_COPY_ELISION_MSG ${VECTOR_COPY_ELISION_MSG_LIST}) |
| |
| set(VECTOR_COPY_ELISION_LEVEL "selection" CACHE STRING ${VECTOR_COPY_ELISION_MSG}) |
| set_property(CACHE VECTOR_COPY_ELISION_LEVEL PROPERTY STRINGS none selection join joinwithbinaryexpressions) |
| |
| if (${VECTOR_COPY_ELISION_LEVEL} STREQUAL "none") |
| message("Vector copy elision level set to: none") |
| elseif(${VECTOR_COPY_ELISION_LEVEL} STREQUAL "selection") |
| message("Vector copy elision level set to: single-relation selection") |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION |
| ) |
| elseif(${VECTOR_COPY_ELISION_LEVEL} STREQUAL "join") |
| message("Vector copy elision level set to: joins (limited to one side of binary expressions)") |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION |
| ) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN |
| ) |
| elseif(${VECTOR_COPY_ELISION_LEVEL} STREQUAL "joinwithbinaryexpressions") |
| message("Vector copy elision level set to: joins (including binary expressions)") |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_SELECTION |
| ) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN |
| ) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_COPY_ELISION_JOIN_WITH_BINARY_EXPRESSIONS |
| ) |
| else() |
| message( |
| FATAL_ERROR |
| "Unknown value for VECTOR_COPY_ELISION_LEVEL. Valid choices are: none, selection, join, joinwithbinaryexpressions") |
| endif() |
| |
| # TODO(chasseur): There are some interesting performance experiments we could |
| # do with short-circuiting turned on and off. We could even make it selective |
| # based on the density of the filter bitmap. |
| set(VECTOR_PREDICATE_SHORT_CIRCUIT_MSG_LIST |
| "If enabled, vectorized predicate evaluation for conjunctions and " |
| "disjunctions will keep track of a filter of tuples already known to " |
| "match or not match the overall predicate to reduce the number of " |
| "comparisons that actually need to be checked. Otherwise sub-predicates " |
| "will always be checked for all tuples in a block and their match sets " |
| "will be intersected/unioned after the fact. Turning this option on is " |
| "expected to reduce the number of comparisons performed, but it changes " |
| "the inner loop for predicate evaluation from simply incrementing a " |
| "tuple_id to scanning for bits set in a filter. Which option performs " |
| "best is likely to be dependent on the selectivity of sub-predicates for " |
| "a particular query.") |
| string(REPLACE ";" "" VECTOR_PREDICATE_SHORT_CIRCUIT_MSG ${VECTOR_PREDICATE_SHORT_CIRCUIT_MSG_LIST}) |
| option(ENABLE_VECTOR_PREDICATE_SHORT_CIRCUIT ${VECTOR_PREDICATE_SHORT_CIRCUIT_MSG} ON) |
| if (ENABLE_VECTOR_PREDICATE_SHORT_CIRCUIT) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_VECTOR_PREDICATE_SHORT_CIRCUIT |
| ) |
| endif() |
| |
| option(ENABLE_NETWORK_CLI "Allows use of the network cli" OFF) |
| option(ENABLE_DISTRIBUTED "Use the distributed version of Quickstep" OFF) |
| |
| macro (set_gflags_lib_name) |
| if (BUILD_SHARED_LIBS) |
| set(GFLAGS_LIB_NAME gflags_nothreads-shared) |
| else() |
| set(GFLAGS_LIB_NAME gflags_nothreads-static) |
| endif() |
| endmacro (set_gflags_lib_name) |
| |
| set_gflags_lib_name () |
| |
| # Turn on the QUICKSTEP_DEBUG flag in the source if this is a debug build. |
| if (CMAKE_MAJOR_VERSION GREATER 2) |
| cmake_policy(SET CMP0043 NEW) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:Debug>:QUICKSTEP_DEBUG> |
| ) |
| else() |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG QUICKSTEP_DEBUG |
| ) |
| endif() |
| |
| # Include Google Perftools CPU Profiler. You probably want to |
| # use this option with CMAKE_BUILD_TYPE=RelWithDebInfo. |
| # Pass profiler_file_name to quickstep_cli_shell to actually |
| # run the profiler. The profiler only starts collecting |
| # samples after the first query, so that it runs against a |
| # warm buffer pool and caches. If you want to profile everything, |
| # including the first query run, set the environment variable |
| # CPUPROFILE instead of passing the flag profile_file_name |
| # Use google-pprof on the output file to convert it into a useful |
| # format like graphviz (dot). |
| option(ENABLE_GOOGLE_PROFILER "Include Google Perftools CPU Profiler." OFF) |
| |
| if (ENABLE_GOOGLE_PROFILER) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS QUICKSTEP_ENABLE_PROFILER |
| ) |
| |
| # TODO(navsan) Add a FindGperftools.cmake module and use that here. |
| check_include_files("gperftools/profiler.h" HAVE_GPERFTOOLS_PROFILER) |
| if (NOT HAVE_GPERFTOOLS_PROFILER) |
| message(FATAL_ERROR "Could not find gperftools. Ensure that it is installed.") |
| endif() |
| set(LIBS ${LIBS} profiler) |
| endif() |
| |
| # Link against the system's threading library. |
| find_package(Threads REQUIRED) |
| set(LIBS ${LIBS} ${CMAKE_THREAD_LIBS_INIT}) |
| set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) |
| |
| # Link with libnuma library if it's present |
| find_package(LibNuma) |
| if(LIBNUMA_FOUND) |
| include_directories(${LIBNUMA_INCLUDE_DIR}) |
| endif() |
| |
| # Enable C++14 support. |
| set(CPP14_SUPPORTED FALSE) |
| include(CheckCXXSourceCompiles) |
| if(NOT CPP14_SUPPORTED) |
| if (MSVC_VERSION GREATER 1899) |
| message("Your C++ compiler appears to be Microsoft Visual Studio 2015 or " |
| "better, which supports C++14 by default.") |
| set(CPP14_SUPPORTED TRUE) |
| endif() |
| endif() |
| if (NOT CPP14_SUPPORTED) |
| CHECK_CXX_COMPILER_FLAG("-std=c++14" CXX_COMPILER_SUPPORTS_CPP14) |
| if (CXX_COMPILER_SUPPORTS_CPP14) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") |
| set(CPP14_SUPPORTED TRUE) |
| endif() |
| endif() |
| if (NOT CPP14_SUPPORTED) |
| CHECK_CXX_COMPILER_FLAG("-std=c++1y" CXX_COMPILER_SUPPORTS_CPP1Y) |
| if (CXX_COMPILER_SUPPORTS_CPP1Y) |
| message(WARNING "Your C++ compiler appears to support pre-standardized " |
| "C++14 (AKA C++1y). Quickstep may fail to build if your " |
| "compiler and standard library are not sufficiently C++14 " |
| "compliant.") |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++1y") |
| set(CPP14_SUPPORTED TRUE) |
| endif() |
| endif() |
| if (NOT CPP14_SUPPORTED) |
| CHECK_CXX_COMPILER_FLAG("-std=c++11" CXX_COMPILER_SUPPORTS_CPP11) |
| if (CXX_COMPILER_SUPPORTS_CPP11) |
| message(WARNING "Your C++ compiler appears to support C++11, but does not " |
| "have flags to enable C++14 support. Quickstep may fail " |
| "to build if your compiler and standard library are not " |
| "sufficiently C++14 compliant.") |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") |
| set(CPP14_SUPPORTED TRUE) |
| endif() |
| endif() |
| if (NOT CPP14_SUPPORTED) |
| CHECK_CXX_COMPILER_FLAG("-std=c++0x" CXX_COMPILER_SUPPORTS_CPP0X) |
| if (CXX_COMPILER_SUPPORTS_CPP0X) |
| message(WARNING "Your C++ compiler appears to only support " |
| "pre-standardized C++0X (eventually ratified as C++11). " |
| "Quickstep requires C++14 support, and the build is " |
| "likely to fail if your compiler and standard library are " |
| "not sufficiently C++14 compliant.") |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") |
| set(CPP14_SUPPORTED TRUE) |
| endif() |
| endif() |
| if (NOT CPP14_SUPPORTED) |
| message (WARNING "Could not find flags to enable C++14 or C++11 support for " |
| "your compiler. If your compiler does not support C++14 by " |
| "default, Quickstep will fail to build.") |
| endif() |
| |
| # Also define _ISOC11_SOURCE, which turns on C library declarations from C11. |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS _ISOC11_SOURCE |
| ) |
| |
| # Enable all warnings. |
| if (MSVC) |
| CHECK_CXX_COMPILER_FLAG("/W3" MSVC_HAS_W3) |
| if (MSVC_HAS_W3) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3") |
| endif() |
| else() |
| CHECK_CXX_COMPILER_FLAG("-Wall" COMPILER_HAS_WALL) |
| if (COMPILER_HAS_WALL) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") |
| endif() |
| CHECK_CXX_COMPILER_FLAG("-pedantic" COMPILER_HAS_PEDANTIC) |
| if (COMPILER_HAS_PEDANTIC) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic") |
| endif() |
| |
| # Treat warnings as errors, 'cause we hardcore. |
| CHECK_CXX_COMPILER_FLAG("-Werror" COMPILER_HAS_WERROR) |
| if (COMPILER_HAS_WERROR) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror") |
| endif() |
| |
| # Clang reports such warning when using Protoc 3.0 beta. |
| if(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") |
| CHECK_CXX_COMPILER_FLAG("-Wno-extended-offsetof" COMPILER_HAS_WNO_EXTENDED_OFFSETOF) |
| if (COMPILER_HAS_WNO_EXTENDED_OFFSETOF) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-extended-offsetof") |
| endif() |
| endif() |
| |
| # OSX 10.12+ has deprecated certain system-level APIs which causes protobuf & glog |
| # builds to fail. As a short-term workaround for now, we turn off deprecated |
| # warnings so that they do not cause build failures anymore. |
| # TODO: Remove this workaround by fixing the protobuf_cmake and glog_cmake. |
| if (${CMAKE_SYSTEM} MATCHES "Darwin-1[67].[0-9]*.[0-9]*") |
| if (${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") |
| CHECK_CXX_COMPILER_FLAG("-Wno-error=deprecated-declarations" COMPILER_HAS_WNO_DEPRECATED) |
| if (COMPILER_HAS_WNO_DEPRECATED) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=deprecated-declarations") |
| endif() |
| endif() |
| if(CMAKE_COMPILER_IS_GNUCXX) |
| CHECK_CXX_COMPILER_FLAG("-Wno-deprecated-declarations" COMPILER_HAS_WNO_DEPRECATED) |
| if (COMPILER_HAS_WNO_DEPRECATED) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations") |
| endif() |
| endif() |
| endif() |
| |
| # One of the protobuf headers includes a nested anonymous union within |
| # another anonymous type. Ordinarily we work around this by compiling the |
| # protobuf libraries themselves with "-Wno-nested-anon-types" and including |
| # the protobuf headers as "system" headers so that the compiler automatically |
| # suppresses warnings originating from them. XCode does not honor the |
| # system-include setting, however, so we must instead suppress the warnings |
| # with global CXXFLAGS for the project. |
| # |
| # TODO(chasseur): Once protobuf 3.0 has a stable release and Quickstep has |
| # upgraded, remove this workaround. |
| if (${CMAKE_GENERATOR} MATCHES "Xcode") |
| CHECK_CXX_COMPILER_FLAG("-Wno-nested-anon-types" XCODE_HAS_WNO_NESTED_ANON_TYPES) |
| if (XCODE_HAS_WNO_NESTED_ANON_TYPES) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nested-anon-types") |
| endif() |
| endif() |
| endif() |
| |
| # Option to use LLVM's libc++ even if it is not the default C++ standard |
| # library on this platform. |
| # |
| # NOTE(chasseur): clang is the default compiler and libc++ is the default |
| # standard library on recent versions of FreeBSD and Mac OS X. On some other |
| # OSes (e.g. most Linux distributions), clang will compile against the |
| # platform's default C++ library (e.g. GNU libstdc++) instead for reasons of |
| # ABI/linking compatibility. This option allows us to override that behavior if |
| # we want to. |
| option(USE_LIBCXX "Use LLVM's libc++ instead of the default C++ standard library" OFF) |
| if (USE_LIBCXX) |
| CHECK_CXX_COMPILER_FLAG("-stdlib=libc++" CXX_COMPILER_HAS_LIBCXX) |
| if (NOT CXX_COMPILER_HAS_LIBCXX) |
| message(FATAL_ERROR "USE_LIBCXX is set to ON, but compiler doesn't allow " |
| "-stdlib=libc++ (are you using some compiler other " |
| "than clang++?)") |
| endif() |
| |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") |
| set(THIRD_PARTY_CXX_FLAGS "${THIRD_PARTY_CXX_FLAGS} -stdlib=libc++") |
| |
| # Check that a minimal program compiles and links. Clang will accept the |
| # command-line flag for libc++ even if the library isn't actually installed. |
| CHECK_CXX_SOURCE_COMPILES(" |
| #include <string> |
| #include <iostream> |
| |
| int main() { |
| std::string msg(\"hello world\"); |
| std::cout << msg; |
| return 0; |
| }" LIBCXX_CHECK) |
| if (NOT LIBCXX_CHECK) |
| message(FATAL_ERROR "Compiler accepts -stdlib=libc++ flag, but cannot " |
| "compile programs when it is turned on.") |
| endif() |
| endif() |
| |
| if(CMAKE_COMPILER_IS_GNUCXX) |
| # Optimization flags for GCC. |
| |
| # Strip binaries for release builds, except on Mac OS X, where this confuses |
| # the linker. |
| if (NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")) |
| set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -s") |
| set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} -s") |
| endif() |
| |
| # If using tcmalloc, prevent GCC from optimizing for builtin malloc and friends. |
| if(USE_TCMALLOC) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free") |
| endif() |
| |
| # Automatically optimize for host processor. |
| CHECK_CXX_COMPILER_FLAG("-march=native" GCC_HAS_MARCH_NATIVE) |
| if (GCC_HAS_MARCH_NATIVE) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native") |
| endif() |
| |
| # On 32-bit x86, GCC defaults to using i387 (not a typo) for floating-point |
| # math. This is slower than SSE, and also uses 80-bit temporaries that don't |
| # correspond to any of the IEEE 754 floating-point formats, so that rounding |
| # errors may be introduced relative to FPUs that do math in a normal IEEE 754 |
| # encoding. Using SSE is preferable for both performance and correctness, so |
| # we enable it here. |
| if ((CMAKE_SIZEOF_VOID_P EQUAL 4) |
| AND ((CMAKE_SYSTEM_PROCESSOR MATCHES "[0-6x]86") |
| OR (CMAKE_SYSTEM_PROCESSOR MATCHES "amd64"))) |
| CHECK_CXX_COMPILER_FLAG("-mfpmath=sse" GCC_HAS_MFPMATH_SSE) |
| if (GCC_HAS_MFPMATH_SSE) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpmath=sse") |
| endif() |
| endif() |
| |
| # Loop-transformation optimizations that aren't turned on by -O3 |
| CHECK_CXX_COMPILER_FLAG("-ftree-loop-linear" GCC_HAS_FTREE_LOOP_LINEAR) |
| if (GCC_HAS_FTREE_LOOP_LINEAR) |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ftree-loop-linear") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ftree-loop-linear") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -ftree-loop-linear") |
| endif() |
| |
| CHECK_CXX_COMPILER_FLAG("-ftree-loop-distribution" GCC_HAS_FTREE_LOOP_DISTRIBUTION) |
| if (GCC_HAS_FTREE_LOOP_DISTRIBUTION) |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ftree-loop-distribution") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ftree-loop-distribution") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -ftree-loop-distribution") |
| endif() |
| |
| CHECK_CXX_COMPILER_FLAG("-floop-strip-mine" GCC_HAS_FLOOP_STRIP_MINE) |
| if (GCC_HAS_FLOOP_STRIP_MINE) |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -floop-strip-mine") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -floop-strip-mine") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -floop-strip-mine") |
| endif() |
| |
| CHECK_CXX_COMPILER_FLAG("-floop-block" GCC_HAS_FLOOP_BLOCK) |
| if (GCC_HAS_FLOOP_BLOCK) |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -floop-block") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -floop-block") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -floop-block") |
| endif() |
| |
| if (ENABLE_LTO) |
| # If GCC supports inter-procedural (link-time) optimizations, turn them on. |
| CHECK_CXX_COMPILER_FLAG("-flto" GCC_HAS_FLTO) |
| if (GCC_HAS_FLTO) |
| if(CMAKE_COMPILER_IS_GNUC) |
| set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -flto") |
| set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} -flto") |
| set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} -flto") |
| endif() |
| |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -flto") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -flto") |
| |
| set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -flto") |
| set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} -flto") |
| set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} -flto") |
| endif() |
| endif() |
| elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Clang") |
| # Optimization flags for Clang. |
| |
| # Strip binaries for release builds, except on Mac OS X, where this confuses |
| # the linker. |
| if (NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")) |
| set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -s") |
| set(CMAKE_EXE_LINKER_FLAGS_MINSIZEREL "${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL} -s") |
| endif() |
| |
| # Automatically optimize for host processor. |
| CHECK_CXX_COMPILER_FLAG("-march=native" CLANG_HAS_MARCH_NATIVE) |
| if(CLANG_HAS_MARCH_NATIVE) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native") |
| endif() |
| # Getting LTO to work with clang is a bit of a nightmare because of linker and ar dependencies, so it's not enabled. |
| # set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O4") |
| # set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O4") |
| # set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -Os") |
| elseif(${CMAKE_CXX_COMPILER_ID} MATCHES "Intel") |
| # Optimization flags for the Intel C++ compiler. |
| if (WIN32) |
| # /fast implies /O3 /Qipo /no-prec-div |
| # /QxHost automatically optimizes for host processor. |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /fast /QxHost") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /fast /QxHost") |
| set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /QxHost") |
| else() |
| set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -xHost") |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -no-prec-div") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -no-prec-div") |
| |
| if (ENABLE_LTO) |
| # Inter-procedural optimization requires using Intel's xiar tool instead |
| # of vanilla ar. |
| find_program(XIAR xiar) |
| if(XIAR) |
| set(CMAKE_AR "${XIAR}") |
| |
| set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ipo") |
| set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -ipo") |
| else() |
| message(WARNING "Could not find Intel xiar tool, so turning OFF inter-procedural " |
| "optimizations for release builds.") |
| endif() |
| endif() |
| |
| endif() |
| elseif(MSVC) |
| # Microsoft Visual studio. |
| # Work around variadic template bug. |
| add_definitions( /D _VARIADIC_MAX=10 ) |
| endif() |
| |
| # Set the include directories to the project root directory and the root of the build tree (where |
| # generated headers will go). |
| include_directories(${PROJECT_SOURCE_DIR}) |
| include_directories(${CMAKE_CURRENT_BINARY_DIR}) |
| |
| # Setup for third-party libs. |
| # |
| # NOTE(chasseur): If USE_LIBCXX is on, we should assume that we need to build |
| # external third-party C++ libraries ourselves even if they are installed on |
| # the system, because they may be linked against a different C++ standard |
| # library (e.g. GNU libstdc++) that is not ABI-compatible. This applies only to |
| # C++ libraries; pure C libraries should have no such issue. |
| set(THIRD_PARTY_SOURCE_DIR "${PROJECT_SOURCE_DIR}/third_party/src") |
| include(ExternalProject) |
| |
| if(USE_TCMALLOC) |
| if(WIN32) |
| message(FATAL_ERROR "You are building with tcmalloc on Windows. Our build system can not yet " |
| "produce tcmalloc on Windows (and the tcmalloc port for Windows is " |
| "incomplete anyway). You should use the system-provided malloc instead " |
| "(invoke cmake with \"-D USE_TCMALLOC=0\").") |
| elseif(NOT UNIX) |
| message(WARNING "Your system does not appear to be UNIX or Windows, but you are building with " |
| "tcmalloc. This is quite likely to fail, in which case you should use the " |
| "system-provided malloc instead (invoke cmake with \"-D USE_TCMALLOC=0\").") |
| elseif(CYGWIN) |
| message(WARNING "You are building with tcmalloc on Windows. For many configurations, this is " |
| "not stable. If you experience build errors, or runtime hangs/crashes, you " |
| "should use the system-provided malloc instead (invoke cmake with " |
| "\"-D USE_TCMALLOC=0\").") |
| endif() |
| |
| # Build tcmalloc as a cmake ExternalProject. |
| ExternalProject_Add( |
| libtcmalloc_ext |
| PREFIX ${CMAKE_CURRENT_BINARY_DIR}/third_party/gperftools |
| SOURCE_DIR ${THIRD_PARTY_SOURCE_DIR}/gperftools |
| CONFIGURE_COMMAND <SOURCE_DIR>/configure |
| --prefix=<INSTALL_DIR> |
| --enable-minimal |
| --disable-debugalloc |
| CC=${CMAKE_C_COMPILER} |
| CXX=${CMAKE_CXX_COMPILER} |
| CFLAGS=${THIRD_PARTY_C_FLAGS} |
| CXXFLAGS=${THIRD_PARTY_CXX_FLAGS} |
| BUILD_COMMAND make |
| BUILD_IN_SOURCE 0 |
| # Uncomment the next line to change the path of the build by products |
| # as some generators, e.g. Ninja, may need it to build properly |
| # BUILD_BYPRODUCTS <INSTALL_DIR>/lib/libtcmalloc_minimal.a |
| ) |
| if (BUILD_SHARED_LIBS) |
| add_library(libtcmalloc_minimal SHARED IMPORTED) |
| set_property(TARGET libtcmalloc_minimal PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/third_party/gperftools/lib/libtcmalloc_minimal.so) |
| else() |
| add_library(libtcmalloc_minimal STATIC IMPORTED) |
| set_property(TARGET libtcmalloc_minimal PROPERTY IMPORTED_LOCATION ${CMAKE_CURRENT_BINARY_DIR}/third_party/gperftools/lib/libtcmalloc_minimal.a) |
| endif() |
| # Linking against tcmalloc also requires linking against the system threading |
| # library. |
| set_property(TARGET libtcmalloc_minimal PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) |
| add_dependencies(libtcmalloc_minimal libtcmalloc_ext) |
| set(LIBS ${LIBS} libtcmalloc_minimal) |
| |
| # With tcmalloc enabled, utility/Alignment.hpp includes tcmalloc.h, which can |
| # trigger a compiler warning about the linkage of the tc_mallinfo() function. |
| # This supresses that warning. |
| CHECK_CXX_COMPILER_FLAG("-Wno-return-type-c-linkage" |
| COMPILER_HAS_WNO_RETURN_TYPE_C_LINKAGE) |
| if (COMPILER_HAS_WNO_RETURN_TYPE_C_LINKAGE) |
| set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-return-type-c-linkage") |
| endif() |
| include_directories(${CMAKE_CURRENT_BINARY_DIR}/third_party) |
| endif() |
| |
| # Add Protocol Buffers. |
| # First, see if protobufs are already installed on this system (unless |
| # USE_LIBCXX is on, in which case we compile ourselves to be safe, in |
| # accordance with the above note). |
| set(PROTOBUF_GLOBAL_DEPS) |
| if (NOT USE_LIBCXX) |
| include(FindProtobuf) |
| endif() |
| if(NOT PROTOBUF_FOUND) |
| # Build the copy of protobufs in third_party/ |
| add_subdirectory("${THIRD_PARTY_SOURCE_DIR}/protobuf_cmake" "${CMAKE_CURRENT_BINARY_DIR}/third_party/protobuf") |
| set(PROTOBUF_FOUND 1) |
| set(PROTOBUF_INCLUDE_DIR "${THIRD_PARTY_SOURCE_DIR}/protobuf/src") |
| set(PROTOBUF_LIBRARY libprotobuf) |
| set(PROTOBUF_GLOBAL_DEPS protoc) |
| set(PROTOBUF_PROTOC_EXECUTABLE protoc) |
| endif() |
| include_directories(SYSTEM ${PROTOBUF_INCLUDE_DIR}) |
| |
| # Add gtest unit-testing framework. |
| set(gtest_force_shared_crt ON CACHE BOOL "Link gtest against shared DLLs on Windows") |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/googletest/googletest" |
| "${CMAKE_CURRENT_BINARY_DIR}/third_party/googletest/googletest") |
| include_directories(SYSTEM "${THIRD_PARTY_SOURCE_DIR}/googletest/googletest/include") |
| enable_testing() |
| |
| if (UNIX) |
| # Add google/benchmark micro-benchmarking framework. |
| # This does not build in Windows. It builds fine on NetBSD, but produces |
| # executables that always segfault on startup. |
| if (${CMAKE_SYSTEM_NAME} MATCHES "NetBSD") |
| message(WARNING "Building micro-benchmarks on NetBSD using google " |
| "benchmark library. This will build fine, but as of " |
| "NetBSD 6.1.5 the micro-benchmark executables always " |
| "segfault on startup due to a bug in the implementation " |
| "of c++11 threads on top of NetBSD's pthread library. " |
| "This issue ONLY affects micro-benchmarks; quickstep " |
| "itself, as well as unit tests and other utilities are " |
| "not affected.") |
| endif() |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/benchmark" "${CMAKE_CURRENT_BINARY_DIR}/third_party/benchmark") |
| include_directories("${THIRD_PARTY_SOURCE_DIR}/benchmark/include") |
| endif() |
| |
| # Add required cmake-controlled third-party libraries (farmhash, gflags, glog, and re2). |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/farmhash" "${CMAKE_CURRENT_BINARY_DIR}/third_party/farmhash") |
| include_directories("${THIRD_PARTY_SOURCE_DIR}") |
| |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/gflags" "${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags") |
| include_directories("${CMAKE_CURRENT_BINARY_DIR}/third_party/gflags/include") |
| |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/glog" "${CMAKE_CURRENT_BINARY_DIR}/third_party/glog") |
| if (WIN32) |
| set_property( |
| DIRECTORY |
| APPEND PROPERTY COMPILE_DEFINITIONS GOOGLE_GLOG_DLL_DECL= |
| ) |
| include_directories(${THIRD_PARTY_SOURCE_DIR}/glog/src/windows) |
| else() |
| include_directories(${THIRD_PARTY_SOURCE_DIR}/glog/src) |
| include_directories(${CMAKE_CURRENT_BINARY_DIR}/third_party/glog) |
| endif() |
| |
| include_directories("${THIRD_PARTY_SOURCE_DIR}/re2") |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/re2" "${CMAKE_CURRENT_BINARY_DIR}/third_party/re2") |
| |
| # Add optional linenoise command-line editing library. |
| if (USE_LINENOISE) |
| if (NOT HAVE_LINENOISE_HEADERS) |
| message(WARNING "You are attempting to enable the linenoise command-line " |
| "editing library, but CMake was unable to find the " |
| "necessary headers on your system. Your build is likely " |
| "to fail, in which case you should try again with " |
| "-D USE_LINENOISE=0") |
| endif() |
| add_subdirectory ("${THIRD_PARTY_SOURCE_DIR}/linenoise" "${CMAKE_CURRENT_BINARY_DIR}/third_party/linenoise") |
| endif() |
| |
| # Add optional libhdfs3 library |
| if (ENABLE_HDFS) |
| find_package(Libhdfs3 REQUIRED) |
| include_directories(${LIBHDFS3_INCLUDE_DIR}) |
| endif() |
| |
| # Check if the BitWeaving index is included. |
| if(EXISTS "${PROJECT_SOURCE_DIR}/storage/bitweaving/BitWeavingIndexSubBlock.hpp") |
| set(QUICKSTEP_HAVE_BITWEAVING TRUE) |
| else() |
| set(QUICKSTEP_HAVE_BITWEAVING FALSE) |
| endif() |
| |
| # Add TMB, but only enable the PureMemory implementation. |
| set(ENABLE_PUREMEMORY ON CACHE BOOL "Enable PureMemory TMB") |
| set(ENABLE_LEVELDB OFF CACHE BOOL "Enable LevelDB TMB") |
| set(ENABLE_MEMORYMIRROR OFF CACHE BOOL "Enable MemoryMirror TMB") |
| set(ENABLE_NATIVELOG OFF CACHE BOOL "Enable NativeLog TMB") |
| |
| # The distributed version requires to use the NativeNet implementation. |
| if (NOT ENABLE_DISTRIBUTED) |
| set(ENABLE_NATIVENET OFF CACHE BOOL "Enable NativeNet TMB") |
| endif() |
| |
| set(ENABLE ENABLE_SQLITE OFF CACHE BOOL "Enable SQLite TMB") |
| set(ENABLE_VOLTDB OFF CACHE BOOL "Enable VoltDB TMB") |
| set(ENABLE_ZOOKEEPER OFF CACHE BOOL "Enable Zookeeper TMB") |
| |
| add_subdirectory("${THIRD_PARTY_SOURCE_DIR}/tmb" "${CMAKE_CURRENT_BINARY_DIR}/third_party/tmb") |
| include_directories(${TMB_INCLUDE_DIRS}) |
| |
| if (ENABLE_DISTRIBUTED) |
| include_directories(${CMAKE_CURRENT_BINARY_DIR}/third_party/tmb/include) |
| endif() |
| |
| # Add all of the module subdirectories. CMakeLists.txt in each of the subdirectories |
| # defines how to build that module's libraries. |
| add_subdirectory(catalog) |
| add_subdirectory(cli) |
| add_subdirectory(compression) |
| add_subdirectory(expressions) |
| add_subdirectory(parser) |
| add_subdirectory(query_execution) |
| add_subdirectory(query_optimizer) |
| add_subdirectory(relational_operators) |
| add_subdirectory(storage) |
| add_subdirectory(threading) |
| add_subdirectory(transaction) |
| add_subdirectory(types) |
| add_subdirectory(utility) |
| add_subdirectory(yarn) |
| |
| # Build the quickstep_cli_shell executable. |
| add_executable (quickstep_cli_shell cli/QuickstepCli.cpp) |
| # Link against direct deps (will transitively pull in everything needed). |
| target_link_libraries(quickstep_cli_shell |
| ${GFLAGS_LIB_NAME} |
| glog |
| quickstep_catalog_CatalogRelation |
| quickstep_cli_CommandExecutor |
| quickstep_cli_DefaultsConfigurator |
| quickstep_cli_DropRelation |
| quickstep_cli_Flags |
| quickstep_cli_InputParserUtil |
| quickstep_cli_LineReader |
| quickstep_cli_LocalIO |
| quickstep_cli_PrintToScreen |
| quickstep_parser_ParseStatement |
| quickstep_parser_SqlParserWrapper |
| quickstep_queryexecution_ForemanSingleNode |
| quickstep_queryexecution_QueryContext |
| quickstep_queryexecution_QueryExecutionTypedefs |
| quickstep_queryexecution_QueryExecutionUtil |
| quickstep_queryexecution_Worker |
| quickstep_queryexecution_WorkerDirectory |
| quickstep_queryoptimizer_QueryHandle |
| quickstep_queryoptimizer_QueryProcessor |
| quickstep_storage_Flags |
| quickstep_storage_PreloaderThread |
| quickstep_storage_StorageConstants |
| quickstep_storage_StorageManager |
| quickstep_threading_ThreadIDBasedMap |
| quickstep_utility_ExecutionDAGVisualizer |
| quickstep_utility_Macros |
| quickstep_utility_PtrVector |
| quickstep_utility_ScopedReassignment |
| quickstep_utility_SqlError |
| quickstep_utility_StringUtil) |
| if (ENABLE_HDFS) |
| target_link_libraries(quickstep_cli_shell |
| quickstep_storage_FileManagerHdfs) |
| endif() |
| if (ENABLE_NETWORK_CLI) |
| target_link_libraries(quickstep_cli_shell |
| quickstep_cli_NetworkIO) |
| endif() |
| # Link against other required system and third-party libraries. |
| target_link_libraries(quickstep_cli_shell ${LIBS}) |
| |
| if (ENABLE_DISTRIBUTED) |
| # Build the quickstep_distributed_cli_shell executable. |
| add_executable (quickstep_distributed_cli_shell |
| cli/distributed/Cli.hpp |
| cli/distributed/Cli.cpp |
| cli/distributed/QuickstepDistributedCli.cpp) |
| # Link against direct deps (will transitively pull in everything needed). |
| target_link_libraries(quickstep_distributed_cli_shell |
| glog |
| quickstep_catalog_CatalogRelation |
| quickstep_cli_Constants |
| quickstep_cli_Flags |
| quickstep_cli_LineReader |
| quickstep_cli_PrintToScreen |
| quickstep_cli_distributed_Conductor |
| quickstep_cli_distributed_Executor |
| quickstep_cli_distributed_Role |
| quickstep_parser_ParseStatement |
| quickstep_parser_SqlParserWrapper |
| quickstep_queryexecution_BlockLocatorUtil |
| quickstep_queryexecution_QueryExecutionMessages_proto |
| quickstep_queryexecution_QueryExecutionTypedefs |
| quickstep_queryexecution_QueryExecutionUtil |
| quickstep_storage_DataExchangerAsync |
| quickstep_storage_StorageBlockInfo |
| quickstep_storage_StorageManager |
| quickstep_utility_Macros |
| quickstep_utility_SqlError |
| quickstep_utility_StringUtil |
| tmb |
| ${GFLAGS_LIB_NAME} |
| ${GRPCPLUSPLUS_LIBRARIES}) |
| endif(ENABLE_DISTRIBUTED) |
| |
| if (ENABLE_NETWORK_CLI) |
| add_executable (quickstep_client cli/NetworkCliClientMain.cpp) |
| target_link_libraries(quickstep_client |
| ${GFLAGS_LIB_NAME} |
| ${GRPCPLUSPLUS_LIBRARIES} |
| glog |
| quickstep_cli_LineReaderBuffered |
| quickstep_cli_NetworkCliClient |
| quickstep_cli_NetworkIO) |
| endif() |