From ad0bc833209b7851c6315df5e95052b41fbabc7c Mon Sep 17 00:00:00 2001 From: Robert Maynard Date: Mon, 10 Feb 2014 13:56:40 -0500 Subject: [PATCH] Add in the basic CMake Infrastructure required for vtkm. --- CMake/CheckCXX11Features.cmake | 142 ++++++ .../cxx11-test-__func__.cpp | 8 + CMake/CheckCXX11Features/cxx11-test-auto.cpp | 12 + .../cxx11-test-auto_fail_compile.cpp | 7 + .../cxx11-test-auto_ret_type.cpp | 8 + .../cxx11-test-class_override_final.cpp | 21 + ...test-class_override_final_fail_compile.cpp | 25 + .../cxx11-test-constexpr.cpp | 19 + .../CheckCXX11Features/cxx11-test-cstdint.cpp | 11 + .../cxx11-test-decltype.cpp | 10 + .../cxx11-test-initializer_list.cpp | 27 ++ .../CheckCXX11Features/cxx11-test-lambda.cpp | 5 + .../cxx11-test-long_long.cpp | 7 + .../CheckCXX11Features/cxx11-test-nullptr.cpp | 6 + .../cxx11-test-nullptr_fail_compile.cpp | 6 + CMake/CheckCXX11Features/cxx11-test-regex.cpp | 26 ++ .../cxx11-test-rvalue-references.cpp | 57 +++ .../cxx11-test-sizeof_member.cpp | 14 + .../cxx11-test-sizeof_member_fail.cpp | 9 + .../cxx11-test-static_assert.cpp | 5 + .../cxx11-test-static_assert_fail_compile.cpp | 5 + .../cxx11-test-variadic_templates.cpp | 23 + CMake/FindBoostHeaders.cmake | 438 ++++++++++++++++++ CMake/TestBuild.cxx.in | 13 + CMake/VtkmCheckCopyright.cmake | 245 ++++++++++ CMake/VtkmCompilerExtras.cmake | 56 +++ CMake/VtkmConfig.cmake.in | 40 ++ CMake/VtkmConfigVersion.cmake.in | 10 + CMake/VtkmCopyrightStatement.txt | 17 + CMake/VtkmMacros.cmake | 343 ++++++++++++++ CMakeLists.txt | 156 +++++++ 31 files changed, 1771 insertions(+) create mode 100644 CMake/CheckCXX11Features.cmake create mode 100644 CMake/CheckCXX11Features/cxx11-test-__func__.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-auto.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-constexpr.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-cstdint.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-decltype.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-lambda.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-long_long.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-nullptr.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-regex.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-static_assert.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp create mode 100644 CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp create mode 100644 CMake/FindBoostHeaders.cmake create mode 100644 CMake/TestBuild.cxx.in create mode 100644 CMake/VtkmCheckCopyright.cmake create mode 100644 CMake/VtkmCompilerExtras.cmake create mode 100644 CMake/VtkmConfig.cmake.in create mode 100644 CMake/VtkmConfigVersion.cmake.in create mode 100644 CMake/VtkmCopyrightStatement.txt create mode 100644 CMake/VtkmMacros.cmake create mode 100644 CMakeLists.txt diff --git a/CMake/CheckCXX11Features.cmake b/CMake/CheckCXX11Features.cmake new file mode 100644 index 000000000..05c986ce6 --- /dev/null +++ b/CMake/CheckCXX11Features.cmake @@ -0,0 +1,142 @@ +# - Check which parts of the C++11 standard the compiler supports +# +# When found it will set the following variables +# +# CXX11_COMPILER_FLAGS - the compiler flags needed to get C++11 features +# +# HAS_CXX11_AUTO - auto keyword +# HAS_CXX11_AUTO_RET_TYPE - function declaration with deduced return types +# HAS_CXX11_CLASS_OVERRIDE - override and final keywords for classes and methods +# HAS_CXX11_CONSTEXPR - constexpr keyword +# HAS_CXX11_CSTDINT_H - cstdint header +# HAS_CXX11_DECLTYPE - decltype keyword +# HAS_CXX11_FUNC - __func__ preprocessor constant +# HAS_CXX11_INITIALIZER_LIST - initializer list +# HAS_CXX11_LAMBDA - lambdas +# HAS_CXX11_LIB_REGEX - regex library +# HAS_CXX11_LONG_LONG - long long signed & unsigned types +# HAS_CXX11_NULLPTR - nullptr +# HAS_CXX11_RVALUE_REFERENCES - rvalue references +# HAS_CXX11_SIZEOF_MEMBER - sizeof() non-static members +# HAS_CXX11_STATIC_ASSERT - static_assert() +# HAS_CXX11_VARIADIC_TEMPLATES - variadic templates + +#============================================================================= +# Copyright 2011,2012 Rolf Eike Beer +# Copyright 2012 Andreas Weis +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= +# (To distribute this file outside of CMake, substitute the full +# License text for the above reference.) + +# +# Each feature may have up to 3 checks, every one of them in it's own file +# FEATURE.cpp - example that must build and return 0 when run +# FEATURE_fail.cpp - example that must build, but may not return 0 when run +# FEATURE_fail_compile.cpp - example that must fail compilation +# +# The first one is mandatory, the latter 2 are optional and do not depend on +# each other (i.e. only one may be present). +# + +if (NOT CMAKE_CXX_COMPILER_LOADED) + message(FATAL_ERROR "CheckCXX11Features modules only works if language CXX is enabled") +endif () + +cmake_minimum_required(VERSION 2.8.3) + +# +### Check for needed compiler flags +# +include(CheckCXXCompilerFlag) +check_cxx_compiler_flag("-std=c++11" _HAS_CXX11_FLAG) +if (NOT _HAS_CXX11_FLAG) + check_cxx_compiler_flag("-std=c++0x" _HAS_CXX0X_FLAG) +endif () + +if (_HAS_CXX11_FLAG) + set(CXX11_COMPILER_FLAGS "-std=c++11") +elseif (_HAS_CXX0X_FLAG) + set(CXX11_COMPILER_FLAGS "-std=c++0x") +endif () + +function(cxx11_check_feature FEATURE_NAME RESULT_VAR) + if (NOT DEFINED ${RESULT_VAR}) + set(_bindir "${CMAKE_CURRENT_BINARY_DIR}/cxx11_${FEATURE_NAME}") + + set(_SRCFILE_BASE ${CMAKE_CURRENT_LIST_DIR}/CheckCXX11Features/cxx11-test-${FEATURE_NAME}) + set(_LOG_NAME "\"${FEATURE_NAME}\"") + message(STATUS "Checking C++11 support for ${_LOG_NAME}") + + set(_SRCFILE "${_SRCFILE_BASE}.cpp") + set(_SRCFILE_FAIL "${_SRCFILE_BASE}_fail.cpp") + set(_SRCFILE_FAIL_COMPILE "${_SRCFILE_BASE}_fail_compile.cpp") + + if (CROSS_COMPILING) + try_compile(${RESULT_VAR} "${_bindir}" "${_SRCFILE}" + COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}") + if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL}) + try_compile(${RESULT_VAR} "${_bindir}_fail" "${_SRCFILE_FAIL}" + COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}") + endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL}) + else (CROSS_COMPILING) + try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR + "${_bindir}" "${_SRCFILE}" + COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}") + if (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR) + set(${RESULT_VAR} TRUE) + else (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR) + set(${RESULT_VAR} FALSE) + endif (_COMPILE_RESULT_VAR AND NOT _RUN_RESULT_VAR) + if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL}) + try_run(_RUN_RESULT_VAR _COMPILE_RESULT_VAR + "${_bindir}_fail" "${_SRCFILE_FAIL}" + COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}") + if (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR) + set(${RESULT_VAR} TRUE) + else (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR) + set(${RESULT_VAR} FALSE) + endif (_COMPILE_RESULT_VAR AND _RUN_RESULT_VAR) + endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL}) + endif (CROSS_COMPILING) + if (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE}) + try_compile(_TMP_RESULT "${_bindir}_fail_compile" "${_SRCFILE_FAIL_COMPILE}" + COMPILE_DEFINITIONS "${CXX11_COMPILER_FLAGS}") + if (_TMP_RESULT) + set(${RESULT_VAR} FALSE) + else (_TMP_RESULT) + set(${RESULT_VAR} TRUE) + endif (_TMP_RESULT) + endif (${RESULT_VAR} AND EXISTS ${_SRCFILE_FAIL_COMPILE}) + + if (${RESULT_VAR}) + message(STATUS "Checking C++11 support for ${_LOG_NAME}: works") + else (${RESULT_VAR}) + message(STATUS "Checking C++11 support for ${_LOG_NAME}: not supported") + endif (${RESULT_VAR}) + set(${RESULT_VAR} ${${RESULT_VAR}} CACHE INTERNAL "C++11 support for ${_LOG_NAME}") + endif (NOT DEFINED ${RESULT_VAR}) +endfunction(cxx11_check_feature) + +cxx11_check_feature("__func__" HAS_CXX11_FUNC) +cxx11_check_feature("auto" HAS_CXX11_AUTO) +cxx11_check_feature("auto_ret_type" HAS_CXX11_AUTO_RET_TYPE) +cxx11_check_feature("class_override_final" HAS_CXX11_CLASS_OVERRIDE) +cxx11_check_feature("constexpr" HAS_CXX11_CONSTEXPR) +cxx11_check_feature("cstdint" HAS_CXX11_CSTDINT_H) +cxx11_check_feature("decltype" HAS_CXX11_DECLTYPE) +cxx11_check_feature("initializer_list" HAS_CXX11_INITIALIZER_LIST) +cxx11_check_feature("lambda" HAS_CXX11_LAMBDA) +cxx11_check_feature("long_long" HAS_CXX11_LONG_LONG) +cxx11_check_feature("nullptr" HAS_CXX11_NULLPTR) +cxx11_check_feature("regex" HAS_CXX11_LIB_REGEX) +cxx11_check_feature("rvalue-references" HAS_CXX11_RVALUE_REFERENCES) +cxx11_check_feature("sizeof_member" HAS_CXX11_SIZEOF_MEMBER) +cxx11_check_feature("static_assert" HAS_CXX11_STATIC_ASSERT) +cxx11_check_feature("variadic_templates" HAS_CXX11_VARIADIC_TEMPLATES) diff --git a/CMake/CheckCXX11Features/cxx11-test-__func__.cpp b/CMake/CheckCXX11Features/cxx11-test-__func__.cpp new file mode 100644 index 000000000..3bfd8a893 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-__func__.cpp @@ -0,0 +1,8 @@ +int main(void) +{ + if (!__func__) + return 1; + if (!(*__func__)) + return 1; + return 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-auto.cpp b/CMake/CheckCXX11Features/cxx11-test-auto.cpp new file mode 100644 index 000000000..948648e99 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-auto.cpp @@ -0,0 +1,12 @@ + +int main() +{ + auto i = 5; + auto f = 3.14159f; + auto d = 3.14159; + bool ret = ( + (sizeof(f) < sizeof(d)) && + (sizeof(i) == sizeof(int)) + ); + return ret ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp b/CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp new file mode 100644 index 000000000..3c0e3f2e0 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp @@ -0,0 +1,7 @@ +int main(void) +{ + // must fail because there is no initializer + auto i; + + return 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp b/CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp new file mode 100644 index 000000000..937b68355 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp @@ -0,0 +1,8 @@ +auto foo(int i) -> int { + return i - 1; +} + +int main() +{ + return foo(1); +} diff --git a/CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp b/CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp new file mode 100644 index 000000000..f5870b199 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp @@ -0,0 +1,21 @@ +class base { +public: + virtual int foo(int a) + { return 4 + a; } + int bar(int a) final + { return a - 2; } +}; + +class sub final : public base { +public: + virtual int foo(int a) override + { return 8 + 2 * a; }; +}; + +int main(void) +{ + base b; + sub s; + + return (b.foo(2) * 2 == s.foo(2)) ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp b/CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp new file mode 100644 index 000000000..bc00b278e --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp @@ -0,0 +1,25 @@ +class base { +public: + virtual int foo(int a) + { return 4 + a; } + virtual int bar(int a) final + { return a - 2; } +}; + +class sub final : public base { +public: + virtual int foo(int a) override + { return 8 + 2 * a; }; + virtual int bar(int a) + { return a; } +}; + +class impossible : public sub { }; + +int main(void) +{ + base b; + sub s; + + return 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-constexpr.cpp b/CMake/CheckCXX11Features/cxx11-test-constexpr.cpp new file mode 100644 index 000000000..ed624512d --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-constexpr.cpp @@ -0,0 +1,19 @@ +constexpr int square(int x) +{ + return x*x; +} + +constexpr int the_answer() +{ + return 42; +} + +int main() +{ + int test_arr[square(3)]; + bool ret = ( + (square(the_answer()) == 1764) && + (sizeof(test_arr)/sizeof(test_arr[0]) == 9) + ); + return ret ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-cstdint.cpp b/CMake/CheckCXX11Features/cxx11-test-cstdint.cpp new file mode 100644 index 000000000..ca2c72ddd --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-cstdint.cpp @@ -0,0 +1,11 @@ +#include + +int main() +{ + bool test = + (sizeof(int8_t) == 1) && + (sizeof(int16_t) == 2) && + (sizeof(int32_t) == 4) && + (sizeof(int64_t) == 8); + return test ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-decltype.cpp b/CMake/CheckCXX11Features/cxx11-test-decltype.cpp new file mode 100644 index 000000000..0dbb1cc52 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-decltype.cpp @@ -0,0 +1,10 @@ +bool check_size(int i) +{ + return sizeof(int) == sizeof(decltype(i)); +} + +int main() +{ + bool ret = check_size(42); + return ret ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp b/CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp new file mode 100644 index 000000000..35e6c3842 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp @@ -0,0 +1,27 @@ +#include + +class seq { +public: + seq(std::initializer_list list); + + int length() const; +private: + std::vector m_v; +}; + +seq::seq(std::initializer_list list) + : m_v(list) +{ +} + +int seq::length() const +{ + return m_v.size(); +} + +int main(void) +{ + seq a = {18, 20, 2, 0, 4, 7}; + + return (a.length() == 6) ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-lambda.cpp b/CMake/CheckCXX11Features/cxx11-test-lambda.cpp new file mode 100644 index 000000000..4c33ed58d --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-lambda.cpp @@ -0,0 +1,5 @@ +int main() +{ + int ret = 0; + return ([&ret]() -> int { return ret; })(); +} diff --git a/CMake/CheckCXX11Features/cxx11-test-long_long.cpp b/CMake/CheckCXX11Features/cxx11-test-long_long.cpp new file mode 100644 index 000000000..091112756 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-long_long.cpp @@ -0,0 +1,7 @@ +int main(void) +{ + long long l; + unsigned long long ul; + + return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-nullptr.cpp b/CMake/CheckCXX11Features/cxx11-test-nullptr.cpp new file mode 100644 index 000000000..9f4107153 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-nullptr.cpp @@ -0,0 +1,6 @@ +int main(void) +{ + void *v = nullptr; + + return v ? 1 : 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp b/CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp new file mode 100644 index 000000000..6a002bcb7 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp @@ -0,0 +1,6 @@ +int main(void) +{ + int i = nullptr; + + return 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-regex.cpp b/CMake/CheckCXX11Features/cxx11-test-regex.cpp new file mode 100644 index 000000000..2fe01c4fc --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-regex.cpp @@ -0,0 +1,26 @@ +#include +#include + +int parse_line(std::string const& line) +{ + std::string tmp; + if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+//(-)?(\\d)+(\\s)+"))) { + tmp = std::regex_replace(line, std::regex("(-)?(\\d)+//(-)?(\\d)+"), std::string("V")); + } else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) { + tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+"), std::string("V")); + } else if(std::regex_search(line, std::regex("(\\s)+(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+(\\s)+"))) { + tmp = std::regex_replace(line, std::regex("(-)?(\\d)+/(-)?(\\d)+/(-)?(\\d)+"), std::string("V")); + } else { + tmp = std::regex_replace(line, std::regex("(-)?(\\d)+"), std::string("V")); + } + return static_cast(std::count(tmp.begin(), tmp.end(), 'V')); +} + +int main() +{ + bool test = (parse_line("f 7/7/7 -3/3/-3 2/-2/2") == 3) && + (parse_line("f 7//7 3//-3 -2//2") == 3) && + (parse_line("f 7/7 3/-3 -2/2") == 3) && + (parse_line("f 7 3 -2") == 3); + return test ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp b/CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp new file mode 100644 index 000000000..e6e7e5a98 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp @@ -0,0 +1,57 @@ +#include + +class rvmove { +public: + void *ptr; + char *array; + + rvmove() + : ptr(0), + array(new char[10]) + { + ptr = this; + } + + rvmove(rvmove &&other) + : ptr(other.ptr), + array(other.array) + { + other.array = 0; + other.ptr = 0; + } + + ~rvmove() + { + assert(((ptr != 0) && (array != 0)) || ((ptr == 0) && (array == 0))); + delete[] array; + } + + rvmove &operator=(rvmove &&other) + { + delete[] array; + ptr = other.ptr; + array = other.array; + other.array = 0; + other.ptr = 0; + return *this; + } + + static rvmove create() + { + return rvmove(); + } +private: + rvmove(const rvmove &); + rvmove &operator=(const rvmove &); +}; + +int main() +{ + rvmove mine; + if (mine.ptr != &mine) + return 1; + mine = rvmove::create(); + if (mine.ptr == &mine) + return 1; + return 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp b/CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp new file mode 100644 index 000000000..4902fc73e --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp @@ -0,0 +1,14 @@ +struct foo { + char bar; + int baz; +}; + +int main(void) +{ + bool ret = ( + (sizeof(foo::bar) == 1) && + (sizeof(foo::baz) >= sizeof(foo::bar)) && + (sizeof(foo) >= sizeof(foo::bar) + sizeof(foo::baz)) + ); + return ret ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp b/CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp new file mode 100644 index 000000000..0348c2cea --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp @@ -0,0 +1,9 @@ +struct foo { + int baz; + double bar; +}; + +int main(void) +{ + return (sizeof(foo::bar) == 4) ? 0 : 1; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-static_assert.cpp b/CMake/CheckCXX11Features/cxx11-test-static_assert.cpp new file mode 100644 index 000000000..47c2fefb8 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-static_assert.cpp @@ -0,0 +1,5 @@ +int main(void) +{ + static_assert(0 < 1, "your ordering of integers is screwed"); + return 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp b/CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp new file mode 100644 index 000000000..362fcdde9 --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp @@ -0,0 +1,5 @@ +int main(void) +{ + static_assert(1 < 0, "your ordering of integers is screwed"); + return 0; +} diff --git a/CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp b/CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp new file mode 100644 index 000000000..4518e886f --- /dev/null +++ b/CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp @@ -0,0 +1,23 @@ +int Accumulate() +{ + return 0; +} + +template +int Accumulate(T v, Ts... vs) +{ + return v + Accumulate(vs...); +} + +template +int CountElements() +{ + return sizeof...(Is); +} + +int main() +{ + int acc = Accumulate(1, 2, 3, 4, -5); + int count = CountElements<1,2,3,4,5>(); + return ((acc == 5) && (count == 5)) ? 0 : 1; +} diff --git a/CMake/FindBoostHeaders.cmake b/CMake/FindBoostHeaders.cmake new file mode 100644 index 000000000..0544046b3 --- /dev/null +++ b/CMake/FindBoostHeaders.cmake @@ -0,0 +1,438 @@ +# +# - Finds the Boost headers only +# Use this module by invoking find_package with the form: +# find_package(Boost +# [version] [EXACT] # Minimum or EXACT version e.g. 1.36.0 +# [REQUIRED] # Fail with error if Boost is not found +# ) +# +# This module finds boost headers the search for the boost headers results +# reported in variables: +# +# Boost_FOUND - True if headers and requested libraries were found +# Boost_INCLUDE_DIRS - Boost include directories +# Boost_VERSION - BOOST_VERSION value from boost/version.hpp +# Boost_MAJOR_VERSION - Boost major version number (X in X.y.z) +# Boost_MINOR_VERSION - Boost minor version number (Y in x.Y.z) +# Boost_SUBMINOR_VERSION - Boost subminor version number (Z in x.y.Z) +# +# This module reads hints about search locations from variables: +# BOOST_INCLUDEDIR - Preferred include directory e.g. /include +# Boost_NO_SYSTEM_PATHS - Set to ON to disable searching in locations not +# specified by these hint variables. Default is OFF. +# Boost_ADDITIONAL_VERSIONS +# - List of Boost versions not known to this module +# (Boost install locations may contain the version) +# and saves search results persistently in CMake cache entries: +# Boost_INCLUDE_DIR - Directory containing Boost headers +# +# Users may set these hints or results as cache entries. Projects should +# not read these entries directly but instead use the above result variables. +# Note that some hint names start in upper-case "BOOST". One may specify +# these as environment variables if they are not specified as CMake variables +# or cache entries. +# +# This module first searches for the Boost header files using the above hint +# variables and saves the result in +# Boost_INCLUDE_DIR. +# +# +#============================================================================= +# Copyright 2006-2012 Kitware, Inc. +# Copyright 2006-2008 Andreas Schneider +# Copyright 2007 Wengo +# Copyright 2007 Mike Jackson +# Copyright 2008 Andreas Pakulat +# Copyright 2008-2012 Philip Lowman +# +# CMake - Cross Platform Makefile Generator +# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium +# All rights reserved. + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# * Neither the names of Kitware, Inc., the Insight Software Consortium, +# nor the names of their contributors may be used to endorse or promote +# products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# +# ------------------------------------------------------------------------------ +# +# The above copyright and license notice applies to distributions of +# CMake in source and binary form. Some source files contain additional +# notices of original copyright by their contributors; see each source +# for details. Third-party software packages supplied with CMake under +# compatible licenses provide their own copyright notices documented in +# corresponding subdirectories. +# +# ------------------------------------------------------------------------------ +# +# CMake was initially developed by Kitware with the following sponsorship: +# +# * National Library of Medicine at the National Institutes of Health +# as part of the Insight Segmentation and Registration Toolkit (ITK). +# +# * US National Labs (Los Alamos, Livermore, Sandia) ASC Parallel +# Visualization Initiative. +# +# * National Alliance for Medical Image Computing (NAMIC) is funded by the +# National Institutes of Health through the NIH Roadmap for Medical Research, +# Grant U54 EB005149. +# +# * Kitware, Inc. +# +# +# + +#------------------------------------------------------------------------------- +# FindBoost functions & macros +# +macro(_Boost_CHANGE_DETECT changed_var) + set(${changed_var} 0) + foreach(v ${ARGN}) + if(DEFINED _Boost_COMPONENTS_SEARCHED) + if(${v}) + if(_${v}_LAST) + string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED) + else() + set(_${v}_CHANGED 1) + endif() + elseif(_${v}_LAST) + set(_${v}_CHANGED 1) + endif() + if(_${v}_CHANGED) + set(${changed_var} 1) + endif() + else() + set(_${v}_CHANGED 0) + endif() + endforeach() +endmacro() + +# +# Make sure the spelling of boost options is correct +# +function(_Boost_CHECK_SPELLING _var) + if(${_var}) + string(TOUPPER ${_var} _var_UC) + message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling. The proper spelling is ${_var_UC}.") + endif() +endfunction() + +# +# End functions/macros +# +#------------------------------------------------------------------------------- + +#------------------------------------------------------------------------------- +# main. +#------------------------------------------------------------------------------- + +# Check the version of Boost against the requested version. +if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR) + message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34") +endif() + +if(Boost_FIND_VERSION_EXACT) + # The version may appear in a directory with or without the patch + # level, even when the patch level is non-zero. + set(_boost_TEST_VERSIONS + "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}" + "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") +else() + # The user has not requested an exact version. Among known + # versions, find those that are acceptable to the user request. + set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS} + "1.56.0" "1.56" "1.55.0" "1.55" "1.54.0" "1.54" + "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51" + "1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1" + "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42" + "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37" + "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0" + "1.34" "1.33.1" "1.33.0" "1.33") + set(_boost_TEST_VERSIONS) + if(Boost_FIND_VERSION) + set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") + # Select acceptable versions. + foreach(version ${_Boost_KNOWN_VERSIONS}) + if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}") + # This version is high enough. + list(APPEND _boost_TEST_VERSIONS "${version}") + elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99") + # This version is a short-form for the requested version with + # the patch level dropped. + list(APPEND _boost_TEST_VERSIONS "${version}") + endif() + endforeach() + else() + # Any version is acceptable. + set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}") + endif() +endif() + +# The reason that we failed to find Boost. This will be set to a +# user-friendly message when we fail to find some necessary piece of +# Boost. +set(Boost_ERROR_REASON) + +if(Boost_DEBUG) + # Output some of their choices + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "Boost_ADDITIONAL_VERSIONS = ${Boost_ADDITIONAL_VERSIONS}") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "Boost_NO_SYSTEM_PATHS = ${Boost_NO_SYSTEM_PATHS}") +endif() + +_Boost_CHECK_SPELLING(Boost_INCLUDEDIR) + +# Collect environment variable inputs as hints. Do not consider changes. +foreach(v BOOST_INCLUDEDIR) + set(_env $ENV{${v}}) + if(_env) + file(TO_CMAKE_PATH "${_env}" _ENV_${v}) + else() + set(_ENV_${v} "") + endif() +endforeach() + +# Collect inputs and cached results. Detect changes since the last run. +set(_Boost_VARS_DIR + Boost_NO_SYSTEM_PATHS + ) + +if(Boost_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "Declared as CMake or Environmental Variables:") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + " BOOST_INCLUDEDIR = ${BOOST_INCLUDEDIR}") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "_boost_TEST_VERSIONS = ${_boost_TEST_VERSIONS}") +endif() + +# ------------------------------------------------------------------------ +# Search for Boost include DIR +# ------------------------------------------------------------------------ + +set(_Boost_VARS_INC BOOST_INCLUDEDIR Boost_INCLUDE_DIR Boost_ADDITIONAL_VERSIONS) +_Boost_CHANGE_DETECT(_Boost_CHANGE_INCDIR ${_Boost_VARS_DIR} ${_Boost_VARS_INC}) +# Clear Boost_INCLUDE_DIR if it did not change but other input affecting the +# location did. We will find a new one based on the new inputs. +if(_Boost_CHANGE_INCDIR AND NOT _Boost_INCLUDE_DIR_CHANGED) + unset(Boost_INCLUDE_DIR CACHE) +endif() + +if(NOT Boost_INCLUDE_DIR) + set(_boost_INCLUDE_SEARCH_DIRS "") + if(BOOST_INCLUDEDIR) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR}) + elseif(_ENV_BOOST_INCLUDEDIR) + list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_INCLUDEDIR}) + endif() + + if( Boost_NO_SYSTEM_PATHS) + list(APPEND _boost_INCLUDE_SEARCH_DIRS NO_CMAKE_SYSTEM_PATH) + else() + list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS + C:/boost/include + C:/boost + /sw/local/include + ) + endif() + + # Try to find Boost by stepping backwards through the Boost versions + # we know about. + # Build a list of path suffixes for each version. + set(_boost_PATH_SUFFIXES) + foreach(_boost_VER ${_boost_TEST_VERSIONS}) + # Add in a path suffix, based on the required version, ideally + # we could read this from version.hpp, but for that to work we'd + # need to know the include dir already + set(_boost_BOOSTIFIED_VERSION) + + # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0 + if(_boost_VER MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+") + string(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3" + _boost_BOOSTIFIED_VERSION ${_boost_VER}) + elseif(_boost_VER MATCHES "[0-9]+\\.[0-9]+") + string(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2" + _boost_BOOSTIFIED_VERSION ${_boost_VER}) + endif() + + list(APPEND _boost_PATH_SUFFIXES + "boost-${_boost_BOOSTIFIED_VERSION}" + "boost_${_boost_BOOSTIFIED_VERSION}" + "boost/boost-${_boost_BOOSTIFIED_VERSION}" + "boost/boost_${_boost_BOOSTIFIED_VERSION}" + ) + + endforeach() + + if(Boost_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "Include debugging info:") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + " _boost_INCLUDE_SEARCH_DIRS = ${_boost_INCLUDE_SEARCH_DIRS}") + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + " _boost_PATH_SUFFIXES = ${_boost_PATH_SUFFIXES}") + endif() + + # Look for a standard boost header file. + find_path(Boost_INCLUDE_DIR + NAMES boost/config.hpp + HINTS ${_boost_INCLUDE_SEARCH_DIRS} + PATH_SUFFIXES ${_boost_PATH_SUFFIXES} + ) +endif() + +# ------------------------------------------------------------------------ +# Extract version information from version.hpp +# ------------------------------------------------------------------------ + +# Set Boost_FOUND based only on header location and version. +# It will be updated below for component libraries. +if(Boost_INCLUDE_DIR) + if(Boost_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp") + endif() + + # Extract Boost_VERSION and Boost_LIB_VERSION from version.hpp + set(Boost_VERSION 0) + set(Boost_LIB_VERSION "") + file(STRINGS "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS REGEX "#define BOOST_(LIB_)?VERSION ") + set(_Boost_VERSION_REGEX "([0-9]+)") + set(_Boost_LIB_VERSION_REGEX "\"([0-9_]+)\"") + foreach(v VERSION LIB_VERSION) + if("${_boost_VERSION_HPP_CONTENTS}" MATCHES ".*#define BOOST_${v} ${_Boost_${v}_REGEX}.*") + set(Boost_${v} "${CMAKE_MATCH_1}") + endif() + endforeach() + unset(_boost_VERSION_HPP_CONTENTS) + + math(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000") + math(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000") + math(EXPR Boost_SUBMINOR_VERSION "${Boost_VERSION} % 100") + + set(Boost_ERROR_REASON + "${Boost_ERROR_REASON}Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}\nBoost include path: ${Boost_INCLUDE_DIR}") + if(Boost_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "version.hpp reveals boost " + "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}") + endif() + + if(Boost_FIND_VERSION) + # Set Boost_FOUND based on requested version. + set(_Boost_VERSION "${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}") + if("${_Boost_VERSION}" VERSION_LESS "${Boost_FIND_VERSION}") + set(Boost_FOUND 0) + set(_Boost_VERSION_AGE "old") + elseif(Boost_FIND_VERSION_EXACT AND + NOT "${_Boost_VERSION}" VERSION_EQUAL "${Boost_FIND_VERSION}") + set(Boost_FOUND 0) + set(_Boost_VERSION_AGE "new") + else() + set(Boost_FOUND 1) + endif() + if(NOT Boost_FOUND) + # State that we found a version of Boost that is too new or too old. + set(Boost_ERROR_REASON + "${Boost_ERROR_REASON}\nDetected version of Boost is too ${_Boost_VERSION_AGE}. Requested version was ${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}") + if (Boost_FIND_VERSION_PATCH) + set(Boost_ERROR_REASON + "${Boost_ERROR_REASON}.${Boost_FIND_VERSION_PATCH}") + endif () + if (NOT Boost_FIND_VERSION_EXACT) + set(Boost_ERROR_REASON "${Boost_ERROR_REASON} (or newer)") + endif () + set(Boost_ERROR_REASON "${Boost_ERROR_REASON}.") + endif () + else() + # Caller will accept any Boost version. + set(Boost_FOUND 1) + endif() +else() + set(Boost_FOUND 0) + set(Boost_ERROR_REASON + "${Boost_ERROR_REASON}Unable to find the Boost header files. Please set BOOST_INCLUDEDIR to the directory containing Boost's headers.") +endif() + +set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR}) +set(Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR}) + +# ------------------------------------------------------------------------ +# Notification to end user about what was found +# ------------------------------------------------------------------------ + +if(Boost_FOUND) + if(NOT Boost_FIND_QUIETLY) + message(STATUS "Boost version: ${Boost_MAJOR_VERSION}.${Boost_MINOR_VERSION}.${Boost_SUBMINOR_VERSION}") + endif() +else() + if(Boost_FIND_REQUIRED) + message(SEND_ERROR "Unable to find the requested Boost libraries.\n${Boost_ERROR_REASON}") + else() + if(NOT Boost_FIND_QUIETLY) + # we opt not to automatically output Boost_ERROR_REASON here as + # it could be quite lengthy and somewhat imposing in its requests + # Since Boost is not always a required dependency we'll leave this + # up to the end-user. + if(Boost_DEBUG OR Boost_DETAILED_FAILURE_MSG) + message(STATUS "Could NOT find Boost\n${Boost_ERROR_REASON}") + else() + message(STATUS "Could NOT find Boost") + endif() + endif() + endif() +endif() + +# Configure display of cache entries in GUI. +foreach(v ${_Boost_VARS_INC} ${_Boost_VARS_LIB}) + get_property(_type CACHE ${v} PROPERTY TYPE) + if(_type) + set_property(CACHE ${v} PROPERTY ADVANCED 1) + if("x${_type}" STREQUAL "xUNINITIALIZED") + if("x${v}" STREQUAL "xBoost_ADDITIONAL_VERSIONS") + set_property(CACHE ${v} PROPERTY TYPE STRING) + else() + set_property(CACHE ${v} PROPERTY TYPE PATH) + endif() + endif() + endif() +endforeach() + +# Record last used values of input variables so we can +# detect on the next run if the user changed them. +foreach(v + ${_Boost_VARS_INC} ${_Boost_VARS_LIB} + ${_Boost_VARS_DIR} ${_Boost_VARS_NAME} + ) + if(DEFINED ${v}) + set(_${v}_LAST "${${v}}" CACHE INTERNAL "Last used ${v} value.") + else() + unset(_${v}_LAST CACHE) + endif() +endforeach() diff --git a/CMake/TestBuild.cxx.in b/CMake/TestBuild.cxx.in new file mode 100644 index 000000000..4a02e1e76 --- /dev/null +++ b/CMake/TestBuild.cxx.in @@ -0,0 +1,13 @@ +//mark that we are including headers as test for completeness. +//This is used by headers that include thrust to properly define a proper +//device backend / system +#define VTKM_TEST_HEADER_BUILD + +#define BOOST_SP_DISABLE_THREADS + +#include <@dir_prefix@/@header@> + +int Test_Build_For_@headername@() +{ + return 0; +} diff --git a/CMake/VtkmCheckCopyright.cmake b/CMake/VtkmCheckCopyright.cmake new file mode 100644 index 000000000..9f338c4ab --- /dev/null +++ b/CMake/VtkmCheckCopyright.cmake @@ -0,0 +1,245 @@ +##============================================================================ +## Copyright (c) Kitware, Inc. +## All rights reserved. +## See LICENSE.txt for details. +## This software is distributed WITHOUT ANY WARRANTY; without even +## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +## PURPOSE. See the above copyright notice for more information. +## +## Copyright 2014 Sandia Corporation. +## Copyright 2014 UT-Battelle, LLC. +## Copyright 2014. Los Alamos National Security +## +## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +## the U.S. Government retains certain rights in this software. +## +## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +## Laboratory (LANL), the U.S. Government retains certain rights in +## this software. +##============================================================================ + +## This CMake script checks source files for the appropriate VTKM copyright +## statement, which is stored in VTKm_SOURCE_DIR/CMake/VTKmCopyrightStatement.txt. +## To run this script, execute CMake as follows: +## +## cmake -DVTKm_SOURCE_DIR= -P /CMake/VTKMCheckCopyright.cmake +## + +cmake_minimum_required(VERSION 2.8) + +set(FILES_TO_CHECK + *.txt + *.cmake + *.h + *.h.in + *.cxx + *.cu + ) + +set(EXCEPTIONS + LICENSE.txt + README.txt + ) + +if (NOT VTKm_SOURCE_DIR) + message(SEND_ERROR "VTKm_SOURCE_DIR not defined.") +endif (NOT VTKm_SOURCE_DIR) + +set(copyright_file ${VTKm_SOURCE_DIR}/CMake/VTKMCopyrightStatement.txt) + +if (NOT EXISTS ${copyright_file}) + message(SEND_ERROR "Cannot find VTKMCopyrightStatement.txt.") +endif (NOT EXISTS ${copyright_file}) + +set(license_file ${VTKm_SOURCE_DIR}/LICENSE.txt) + +if (NOT EXISTS ${license_file}) + message(SEND_ERROR "Cannot find LICENSE.txt.") +endif (NOT EXISTS ${license_file}) + +# Get a list of third party files (with different copyrights) from the +# license file. +file(STRINGS ${license_file} license_lines) +list(FIND + license_lines + "- - - - - - - - - - - - - - - - - - - - - - - - do not remove this line" + separator_index + ) +math(EXPR begin_index "${separator_index} + 1") +list(LENGTH license_lines license_file_length) +math(EXPR end_index "${license_file_length} - 1") +foreach (index RANGE ${begin_index} ${end_index}) + list(GET license_lines ${index} tpl_file) + set(EXCEPTIONS ${EXCEPTIONS} ${tpl_file}) +endforeach(index) +message("${EXCEPTIONS}") + +# Gets the current year (if possible). +function (get_year var) + if (UNIX) + execute_process(COMMAND "date" "+%Y" OUTPUT_VARIABLE result) + string(REGEX REPLACE "(....).*" "\\1" result "${result}") + elseif (WIN32) + execute_process(COMMAND "date" "/T" OUTPUT_VARIABLE result) + string(REGEX REPLACE ".*../../(....).*" "\\1" result "${result}") + else (UNIX) + message("Don't know how to get date.") + set(result "20XX") + endif (UNIX) + set(${var} "${result}" PARENT_SCOPE) +endfunction (get_year) + +set(copyright_file_year 2011) +get_year(current_year) + +# Escapes ';' characters (list delimiters) and splits the given string into +# a list of its lines without newlines. +function (list_of_lines var string) + string(REGEX REPLACE ";" "\\\\;" conditioned_string "${string}") + string(REGEX REPLACE "\n" ";" conditioned_string "${conditioned_string}") + set(${var} "${conditioned_string}" PARENT_SCOPE) +endfunction (list_of_lines) + +# Read in copyright statement file. +file(READ ${copyright_file} COPYRIGHT_STATEMENT) + +# Remove trailing whitespace and ending lines. They are sometimes hard to +# see or remove in editors. +string(REGEX REPLACE "[ \t]*\n" "\n" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}") +string(REGEX REPLACE "\n+$" "" COPYRIGHT_STATEMENT "${COPYRIGHT_STATEMENT}") + +# Get a list of lines in the copyright statement. +list_of_lines(COPYRIGHT_LINE_LIST "${COPYRIGHT_STATEMENT}") + +# Comment regular expression characters that we want to match literally. +string(REPLACE "." "\\." COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}") +string(REPLACE "(" "\\(" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}") +string(REPLACE ")" "\\)" COPYRIGHT_LINE_LIST "${COPYRIGHT_LINE_LIST}") + +# Introduce regular expression for years we want to be generic. +string(REPLACE + "${copyright_file_year}" + "20[0-9][0-9]" + COPYRIGHT_LINE_LIST + "${COPYRIGHT_LINE_LIST}" + ) + +# Replace year in COPYRIGHT_STATEMENT with current year. +string(REPLACE + "${copyright_file_year}" + "${current_year}" + COPYRIGHT_STATEMENT + "${COPYRIGHT_STATEMENT}" + ) + +# Print an error concerning the missing copyright in the given file. +function(missing_copyright filename comment_prefix) + message("${filename} does not have the appropriate copyright statement:\n") + + # Condition the copyright statement + string(REPLACE + "\n" + "\n${comment_prefix} " + comment_copyright + "${COPYRIGHT_STATEMENT}" + ) + set(comment_copyright "${comment_prefix} ${comment_copyright}") + string(REPLACE + "\n${comment_prefix} \n" + "\n${comment_prefix}\n" + comment_copyright + "${comment_copyright}" + ) + + message("${comment_prefix}=============================================================================") + message("${comment_prefix}") + message("${comment_copyright}") + message("${comment_prefix}") + message("${comment_prefix}=============================================================================\n") + message(SEND_ERROR + "Please add the previous statement to the beginning of ${filename}" + ) +endfunction(missing_copyright) + +# Get an appropriate beginning line comment for the given filename. +function(get_comment_prefix var filename) + get_filename_component(base "${filename}" NAME_WE) + get_filename_component(extension "${filename}" EXT) + if (extension STREQUAL ".cmake") + set(${var} "##" PARENT_SCOPE) + elseif (base STREQUAL "CMakeLists" AND extension STREQUAL ".txt") + set(${var} "##" PARENT_SCOPE) + elseif (extension STREQUAL ".txt") + set(${var} "" PARENT_SCOPE) + elseif (extension STREQUAL ".h" OR extension STREQUAL ".h.in" OR extension STREQUAL ".cxx" OR extension STREQUAL ".cu") + set(${var} "//" PARENT_SCOPE) + elseif (extension STREQUAL ".worklet") + set(${var} "//" PARENT_SCOPE) + else (extension STREQUAL ".cmake") + message(SEND_ERROR "Could not identify file type of ${filename}.") + endif (extension STREQUAL ".cmake") +endfunction(get_comment_prefix) + +# Check the given file for the appropriate copyright statement. +function(check_copyright filename) + + get_comment_prefix(comment_prefix "${filename}") + + # Read in the first 2000 characters of the file and split into lines. + # This is roughly equivalent to the file STRINGS command except that we + # also escape semicolons (list separators) in the input, which the file + # STRINGS command does not currently do. + file(READ "${filename}" header_contents LIMIT 2000) + list_of_lines(header_lines "${header_contents}") + + # Check each copyright line. + foreach (copyright_line IN LISTS COPYRIGHT_LINE_LIST) + set(match) + # My original algorithm tried to check the order by removing items from + # header_lines as they were encountered. Unfortunately, CMake 2.8's + # list REMOVE_AT command removed the escaping on the ; in one of the + # header_line's items and cause the compare to fail. + foreach (header_line IN LISTS header_lines) + if (copyright_line) + string(REGEX MATCH + "^${comment_prefix}[ \t]*${copyright_line}[ \t]*$" + match + "${header_line}" + ) + else (copyright_line) + if (NOT header_line) + set(match TRUE) + endif (NOT header_line) + endif (copyright_line) + if (match) + break() + endif (match) + endforeach (header_line) + if (NOT match) + message(STATUS "Could not find match for `${copyright_line}'") + missing_copyright("${filename}" "${comment_prefix}") + endif (NOT match) + endforeach (copyright_line) +endfunction(check_copyright) + +foreach (glob_expression ${FILES_TO_CHECK}) + file(GLOB_RECURSE file_list + RELATIVE "${VTKm_SOURCE_DIR}" + "${VTKm_SOURCE_DIR}/${glob_expression}" + ) + + foreach (file ${file_list}) + set(skip) + foreach(exception ${EXCEPTIONS}) + if(file MATCHES "^${exception}(/.*)?$") + # This file is an exception + set(skip TRUE) + endif(file MATCHES "^${exception}(/.*)?$") + endforeach(exception) + + if (NOT skip) + message("Checking ${file}") + check_copyright("${VTKm_SOURCE_DIR}/${file}") + endif (NOT skip) + endforeach (file) +endforeach (glob_expression) diff --git a/CMake/VtkmCompilerExtras.cmake b/CMake/VtkmCompilerExtras.cmake new file mode 100644 index 000000000..0623e86da --- /dev/null +++ b/CMake/VtkmCompilerExtras.cmake @@ -0,0 +1,56 @@ +##============================================================================ +## Copyright (c) Kitware, Inc. +## All rights reserved. +## See LICENSE.txt for details. +## This software is distributed WITHOUT ANY WARRANTY; without even +## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +## PURPOSE. See the above copyright notice for more information. +## +## Copyright 2014 Sandia Corporation. +## Copyright 2014 UT-Battelle, LLC. +## Copyright 2014. Los Alamos National Security +## +## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +## the U.S. Government retains certain rights in this software. +## +## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +## Laboratory (LANL), the U.S. Government retains certain rights in +## this software. +##============================================================================ + +if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") + set(CMAKE_COMPILER_IS_CLANGXX 1) +endif() + +if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX) + + include(CheckCXXCompilerFlag) + + # Standard warning flags we should always have + set(CMAKE_CXX_FLAGS_WARN " -Wall") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO + "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN}") + set(CMAKE_CXX_FLAGS_DEBUG + "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN}") + + # Addtional warnings for GCC + set(CMAKE_CXX_FLAGS_WARN_EXTRA "-Wno-long-long -Wcast-align -Wchar-subscripts -Wextra -Wpointer-arith -Wformat -Wformat-security -Wshadow -Wunused-parameter -fno-common") + if (VTKM_FORCE_ANSI) + set(CMAKE_CXX_FLAGS_WARN_EXTRA "-ansi ${CMAKE_CXX_FLAGS_WARN_EXTRA}") + endif() + + # Set up the debug CXX_FLAGS for extra warnings + option(VTKM_EXTRA_COMPILER_WARNINGS "Add compiler flags to do stricter checking when building debug." ON) + # We used to add the compiler flags globally, but this caused problems with + # the CUDA compiler (and its lack of support for GCC pragmas). Instead, + # the vtkm_declare_headers and vtkm_unit_tests CMake functions add these flags + # to their compiles. As long as the unit tests have good coverage, this + # should catch all problems. + if(VTKM_EXTRA_COMPILER_WARNINGS) + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO + "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} ${CMAKE_CXX_FLAGS_WARN_EXTRA}") + set(CMAKE_CXX_FLAGS_DEBUG + "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_WARN_EXTRA}") + endif() +endif() + diff --git a/CMake/VtkmConfig.cmake.in b/CMake/VtkmConfig.cmake.in new file mode 100644 index 000000000..8419566da --- /dev/null +++ b/CMake/VtkmConfig.cmake.in @@ -0,0 +1,40 @@ +##============================================================================ +## Copyright (c) Kitware, Inc. +## All rights reserved. +## See LICENSE.txt for details. +## This software is distributed WITHOUT ANY WARRANTY; without even +## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +## PURPOSE. See the above copyright notice for more information. +## +## Copyright 2014 Sandia Corporation. +## Copyright 2014 UT-Battelle, LLC. +## Copyright 2014. Los Alamos National Security +## +## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +## the U.S. Government retains certain rights in this software. +## +## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +## Laboratory (LANL), the U.S. Government retains certain rights in +## this software. +##============================================================================ + +# This file should be installed in the include directory. +# Find the root directory. +get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_install_dir "${_dir}/.." ABSOLUTE) + +# The VTKm include file directories. +set(VTKm_INCLUDE_DIRS "@VTKm_INCLUDE_DIRS_CONFIG@") + +# The VTKm version number +set(VTKm_MAJOR_VERSION "@VTKm_MAJOR_VERSION@") +set(VTKm_MINOR_VERSION "@VTKm_MINOR_VERSION@") +set(VTKm_PATCH_VERSION "@VTKm_PATCH_VERSION@") + +set(VTKm_REQUIRED_BOOST_VERSION "@VTKm_REQUIRED_BOOST_VERSION@") + +set(VTKm_CMAKE_MODULE_PATH "@VTKm_CMAKE_MODULE_PATH_CONFIG@") + +# VTKm requires some CMake Find modules not included with CMake, so +# include the CMake modules distributed with VTKm. +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_CMAKE_MODULE_PATH}) diff --git a/CMake/VtkmConfigVersion.cmake.in b/CMake/VtkmConfigVersion.cmake.in new file mode 100644 index 000000000..c9ba2c8da --- /dev/null +++ b/CMake/VtkmConfigVersion.cmake.in @@ -0,0 +1,10 @@ +set(PACKAGE_VERSION "@VTKm_VERSION@") + +if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if ("${PACKAGE_VERSION}" STREQUAL "${PACKAGE_FIND_VERSION}") + set(PACKAGE_VERSION_EXACT TRUE) + endif() +endif() diff --git a/CMake/VtkmCopyrightStatement.txt b/CMake/VtkmCopyrightStatement.txt new file mode 100644 index 000000000..f0a91cfe0 --- /dev/null +++ b/CMake/VtkmCopyrightStatement.txt @@ -0,0 +1,17 @@ +Copyright (c) Kitware, Inc. +All rights reserved. +See LICENSE.txt for details. + +This software is distributed WITHOUT ANY WARRANTY; without even +the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +PURPOSE. See the above copyright notice for more information. + +Copyright 2014 Sandia Corporation. +Copyright 2014 UT-Battelle, LLC. +Copyright 2014. Los Alamos National Security + +Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +the U.S. Government retains certain rights in this software. +Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +Laboratory (LANL), the U.S. Government retains certain rights in +this software. diff --git a/CMake/VtkmMacros.cmake b/CMake/VtkmMacros.cmake new file mode 100644 index 000000000..dd8cd8e55 --- /dev/null +++ b/CMake/VtkmMacros.cmake @@ -0,0 +1,343 @@ +##============================================================================ +## Copyright (c) Kitware, Inc. +## All rights reserved. +## See LICENSE.txt for details. +## This software is distributed WITHOUT ANY WARRANTY; without even +## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +## PURPOSE. See the above copyright notice for more information. +## +## Copyright 2014 Sandia Corporation. +## Copyright 2014 UT-Battelle, LLC. +## Copyright 2014. Los Alamos National Security +## +## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +## the U.S. Government retains certain rights in this software. +## +## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +## Laboratory (LANL), the U.S. Government retains certain rights in +## this software. +##============================================================================ + +include(CMakeParseArguments) + +# Utility to build a kit name from the current directory. +function(vtkm_get_kit_name kitvar) + # Will this always work? It should if ${CMAKE_CURRENT_SOURCE_DIR} is + # built from ${VTKm_SOURCE_DIR}. + string(REPLACE "${VTKm_SOURCE_DIR}/" "" dir_prefix ${CMAKE_CURRENT_SOURCE_DIR}) + string(REPLACE "/" "_" kit "${dir_prefix}") + set(${kitvar} "${kit}" PARENT_SCOPE) + # Optional second argument to get dir_prefix. + if (${ARGC} GREATER 1) + set(${ARGV1} "${dir_prefix}" PARENT_SCOPE) + endif (${ARGC} GREATER 1) +endfunction(vtkm_get_kit_name) + +# Builds a source file and an executable that does nothing other than +# compile the given header files. +function(vtkm_add_header_build_test name dir_prefix use_cuda) + set(hfiles ${ARGN}) + if (use_cuda) + set(suffix ".cu") + else (use_cuda) + set(suffix ".cxx") + endif (use_cuda) + set(cxxfiles) + foreach (header ${ARGN}) + get_source_file_property(cant_be_tested ${header} VTKm_CANT_BE_HEADER_TESTED) + + if( NOT cant_be_tested ) + string(REPLACE "${CMAKE_CURRENT_BINARY_DIR}" "" header "${header}") + get_filename_component(headername ${header} NAME_WE) + set(src ${CMAKE_CURRENT_BINARY_DIR}/testing/TestBuild_${name}_${headername}${suffix}) + configure_file(${VTKm_SOURCE_DIR}/CMake/TestBuild.cxx.in ${src} @ONLY) + list(APPEND cxxfiles ${src}) + endif() + + endforeach (header) + + #only attempt to add a test build executable if we have any headers to + #test. this might not happen when everything depends on thrust. + list(LENGTH cxxfiles cxxfiles_len) + if (use_cuda AND ${cxxfiles_len} GREATER 0) + cuda_add_library(TestBuild_${name} ${cxxfiles} ${hfiles}) + elseif (${cxxfiles_len} GREATER 0) + add_library(TestBuild_${name} ${cxxfiles} ${hfiles}) + if(VTKm_EXTRA_COMPILER_WARNINGS) + set_target_properties(TestBuild_${name} + PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA}) + endif(VTKm_EXTRA_COMPILER_WARNINGS) + endif () + set_source_files_properties(${hfiles} + PROPERTIES HEADER_FILE_ONLY TRUE + ) +endfunction(vtkm_add_header_build_test) + +function(vtkm_install_headers dir_prefix) + set(hfiles ${ARGN}) + install(FILES ${hfiles} + DESTINATION ${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix} + ) +endfunction(vtkm_install_headers) + +# Declare a list of headers that require thrust to be enabled +# for them to header tested. In cases of thrust version 1.5 or less +# we have to make sure openMP is enabled, otherwise we are okay +function(vtkm_requires_thrust_to_test) + #determine the state of thrust and testing + set(cant_be_tested FALSE) + if(NOT VTKm_ENABLE_THRUST) + #mark as not valid + set(cant_be_tested TRUE) + elseif(NOT VTKm_ENABLE_OPENMP) + #mark also as not valid + set(cant_be_tested TRUE) + endif() + + foreach(header ${ARGN}) + #set a property on the file that marks if we can header test it + set_source_files_properties( ${header} + PROPERTIES VTKm_CANT_BE_HEADER_TESTED ${cant_be_tested} ) + + endforeach(header) + +endfunction(vtkm_requires_thrust_to_test) + +# Declare a list of header files. Will make sure the header files get +# compiled and show up in an IDE. +function(vtkm_declare_headers) + set(options CUDA) + set(oneValueArgs) + set(multiValueArgs) + cmake_parse_arguments(VTKm_DH "${options}" + "${oneValueArgs}" "${multiValueArgs}" + ${ARGN} + ) + set(hfiles ${VTKm_DH_UNPARSED_ARGUMENTS}) + vtkm_get_kit_name(name dir_prefix) + + #only do header testing if enable testing is turned on + if (VTKm_ENABLE_TESTING) + vtkm_add_header_build_test( + "${name}" "${dir_prefix}" "${VTKm_DH_CUDA}" ${hfiles}) + endif() + #always install headers + vtkm_install_headers("${dir_prefix}" ${hfiles}) +endfunction(vtkm_declare_headers) + +# Declare a list of worklet files. +function(vtkm_declare_worklets) + # Currently worklets are just really header files. + vtkm_declare_headers(${ARGN}) +endfunction(vtkm_declare_worklets) + +# Declare unit tests, which should be in the same directory as a kit +# (package, module, whatever you call it). Usage: +# +# vtkm_unit_tests( +# SOURCES +# LIBRARIES +# ) +function(vtkm_unit_tests) + set(options CUDA) + set(oneValueArgs) + set(multiValueArgs SOURCES LIBRARIES) + cmake_parse_arguments(VTKm_UT + "${options}" "${oneValueArgs}" "${multiValueArgs}" + ${ARGN} + ) + + #set up what we possibly need to link too. + list(APPEND VTKm_UT_LIBRARIES ${TBB_LIBRARIES}) + #set up storage for the include dirs + set(VTKm_UT_INCLUDE_DIRS ) + + if(VTKm_ENABLE_OPENGL_INTEROP) + list(APPEND VTKm_UT_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR} ${GLEW_INCLUDE_DIR} ) + list(APPEND VTKm_UT_LIBRARIES ${OPENGL_LIBRARIES} ${GLEW_LIBRARIES} ) + endif() + + if(VTKm_ENABLE_OPENGL_TESTS) + list(APPEND VTKm_UT_INCLUDE_DIRS ${GLUT_INCLUDE_DIR} ) + list(APPEND VTKm_UT_LIBRARIES ${GLUT_LIBRARIES} ) + endif() + + if (VTKm_ENABLE_TESTING) + vtkm_get_kit_name(kit) + #we use UnitTests_kit_ so that it is an unique key to exclude from coverage + set(test_prog UnitTests_kit_${kit}) + create_test_sourcelist(TestSources ${test_prog}.cxx ${VTKm_UT_SOURCES}) + if (VTKm_UT_CUDA) + cuda_add_executable(${test_prog} ${TestSources}) + else (VTKm_UT_CUDA) + add_executable(${test_prog} ${TestSources}) + if(VTKm_EXTRA_COMPILER_WARNINGS) + set_target_properties(${test_prog} + PROPERTIES COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA}) + endif(VTKm_EXTRA_COMPILER_WARNINGS) + endif (VTKm_UT_CUDA) + + #do it as a property value so we don't pollute the include_directories + #for any other targets + set_property(TARGET ${test_prog} APPEND PROPERTY + INCLUDE_DIRECTORIES ${VTKm_UT_INCLUDE_DIRS} ) + + target_link_libraries(${test_prog} ${VTKm_UT_LIBRARIES}) + + + foreach (test ${VTKm_UT_SOURCES}) + get_filename_component(tname ${test} NAME_WE) + add_test(NAME ${tname} + COMMAND ${test_prog} ${tname} + ) + endforeach (test) + endif (VTKm_ENABLE_TESTING) +endfunction(vtkm_unit_tests) + +# Save the worklets to test with each device adapter +# Usage: +# +# vtkm_save_worklet_unit_tests( sources ) +# +# notes: will save the sources absolute path as the +# vtkm_source_worklet_unit_tests global property +function(vtkm_save_worklet_unit_tests ) + + #create the test driver when we are called, since + #the test driver expect the test files to be in the same + #directory as the test driver + create_test_sourcelist(test_sources WorkletTestDriver.cxx ${ARGN}) + + #store the absolute path for the test drive and all the test + #files + set(driver ${CMAKE_CURRENT_BINARY_DIR}/WorkletTestDriver.cxx) + set(cxx_sources) + set(cu_sources) + + #we need to store the absolute source for the file so that + #we can properly compile it into the test driver. At + #the same time we want to configure each file into the build + #directory as a .cu file so that we can compile it with cuda + #if needed + foreach(fname ${ARGN}) + set(absPath) + + get_filename_component(absPath ${fname} ABSOLUTE) + get_filename_component(file_name_only ${fname} NAME_WE) + + set(cuda_file_name "${CMAKE_CURRENT_BINARY_DIR}/${file_name_only}.cu") + configure_file("${absPath}" + "${cuda_file_name}" + COPYONLY) + list(APPEND cxx_sources ${absPath}) + list(APPEND cu_sources ${cuda_file_name}) + endforeach() + + #we create a property that holds all the worklets to test, + #but don't actually attempt to create a unit test with the yet. + #That is done by each device adapter + set_property( GLOBAL APPEND + PROPERTY vtkm_worklet_unit_tests_sources ${cxx_sources}) + set_property( GLOBAL APPEND + PROPERTY vtkm_worklet_unit_tests_cu_sources ${cu_sources}) + set_property( GLOBAL APPEND + PROPERTY vtkm_worklet_unit_tests_drivers ${driver}) + +endfunction(vtkm_save_worklet_unit_tests) + +# Call each worklet test for the given device adapter +# Usage: +# +# vtkm_worklet_unit_tests( device_adapter ) +# +# notes: will look for the vtkm_source_worklet_unit_tests global +# property to find what are the worklet unit tests that need to be +# compiled for the give device adapter +function(vtkm_worklet_unit_tests device_adapter) + + set(unit_test_srcs) + get_property(unit_test_srcs GLOBAL + PROPERTY vtkm_worklet_unit_tests_sources ) + + set(unit_test_drivers) + get_property(unit_test_drivers GLOBAL + PROPERTY vtkm_worklet_unit_tests_drivers ) + + #detect if we are generating a .cu files + set(is_cuda FALSE) + set(old_nvcc_flags ${CUDA_NVCC_FLAGS}) + if("${device_adapter}" STREQUAL "VTKm_DEVICE_ADAPTER_CUDA") + set(is_cuda TRUE) + #if we are generating cu files need to setup three things. + #1. us the configured .cu files + #2. Set BOOST_SP_DISABLE_THREADS to disable threading warnings + #3. Disable unused function warnings + #the FindCUDA module and helper methods don't read target level + #properties so we have to modify CUDA_NVCC_FLAGS instead of using + # target and source level COMPILE_FLAGS and COMPILE_DEFINITIONS + # + get_property(unit_test_srcs GLOBAL PROPERTY vtkm_worklet_unit_tests_cu_sources ) + list(APPEND CUDA_NVCC_FLAGS -DBOOST_SP_DISABLE_THREADS) + list(APPEND CUDA_NVCC_FLAGS "-w") + endif() + + if(VTKm_ENABLE_TESTING) + vtkm_get_kit_name(kit) + set(test_prog WorkletTests_${kit}) + + if(is_cuda) + cuda_add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs}) + else() + add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs}) + endif() + + #add a test for each worklet test file. We will inject the device + #adapter type into the test name so that it is easier to see what + #exact device a test is failing on. + + string(REPLACE "VTKm_DEVICE_ADAPTER_" "" device_type ${device_adapter}) + + foreach (test ${unit_test_srcs}) + get_filename_component(tname ${test} NAME_WE) + add_test(NAME "${tname}${device_type}" + COMMAND ${test_prog} ${tname} + ) + endforeach (test) + + #increase warning level if needed, we are going to skip cuda here + #to remove all the false positive unused function warnings that cuda + #generates + if(VTKm_EXTRA_COMPILER_WARNINGS) + set_property(TARGET ${test_prog} + APPEND PROPERTY COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA} ) + endif() + + #set the device adapter on the executable + set_property(TARGET ${test_prog} + APPEND + PROPERTY COMPILE_DEFINITIONS VTKm_DEVICE_ADAPTER=${device_adapter}) + endif() + + set(CUDA_NVCC_FLAGS ${old_nvcc_flags}) +endfunction(vtkm_worklet_unit_tests) + +# The Thrust project is not as careful as the VTKm project in avoiding warnings +# on shadow variables and unused arguments. With a real GCC compiler, you +# can disable these warnings inline, but with something like nvcc, those +# pragmas cause errors. Thus, this macro will disable the compiler warnings. +macro(vtkm_disable_troublesome_thrust_warnings) + vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_DEBUG) + vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_MINSIZEREL) + vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELEASE) + vtkm_disable_troublesome_thrust_warnings_var(CMAKE_CXX_FLAGS_RELWITHDEBINFO) +endmacro(vtkm_disable_troublesome_thrust_warnings) + +macro(vtkm_disable_troublesome_thrust_warnings_var flags_var) + set(old_flags "${${flags_var}}") + string(REPLACE "-Wshadow" "" new_flags "${old_flags}") + string(REPLACE "-Wunused-parameter" "" new_flags "${new_flags}") + string(REPLACE "-Wunused" "" new_flags "${new_flags}") + string(REPLACE "-Wextra" "" new_flags "${new_flags}") + string(REPLACE "-Wall" "" new_flags "${new_flags}") + set(${flags_var} "${new_flags}") +endmacro(vtkm_disable_troublesome_thrust_warnings_var) diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 000000000..acfa46f3f --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,156 @@ +##============================================================================ +## Copyright (c) Kitware, Inc. +## All rights reserved. +## See LICENSE.txt for details. +## This software is distributed WITHOUT ANY WARRANTY; without even +## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +## PURPOSE. See the above copyright notice for more information. +## +## Copyright 2014 Sandia Corporation. +## Copyright 2014 UT-Battelle, LLC. +## Copyright 2014. Los Alamos National Security +## +## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, +## the U.S. Government retains certain rights in this software. +## +## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National +## Laboratory (LANL), the U.S. Government retains certain rights in +## this software. +##============================================================================ + +cmake_minimum_required(VERSION 2.8.10) +project (VTKm) + +set(VTKm_MAJOR_VERSION 0) +set(VTKm_MINOR_VERSION 1) +set(VTKm_PATCH_VERSION 0) +set(VTKm_VERSION "${VTKm_MAJOR_VERSION}.${VTKm_MINOR_VERSION}.${VTKm_PATCH_VERSION}") + +set(VTKm_INSTALL_INCLUDE_DIR "include") +set(VTKm_INSTALL_CONFIG_DIR "include") +set(VTKm_INSTALL_CMAKE_MODULE_DIR "share/vtkm/cmake") + +set(VTKm_REQUIRED_BOOST_VERSION 1.48.0) + +# include some vtkm-specific cmake code. +include(CMake/VTKmMacros.cmake) + +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${VTKm_SOURCE_DIR}/CMake) + +#----------------------------------------------------------------------------- +# Check for Cxx11 support. +option(VTKm_FORCE_ANSI + "Turn off compiling any features not compatible with ISO-C++98 (ANSI)." OFF) +if (NOT VTKm_FORCE_ANSI) + include(CMake/CheckCXX11Features.cmake) +else (NOT VTKm_FORCE_ANSI) + set(VTKm_NO_VARIADIC_TEMPLATE TRUE) +endif () + +#----------------------------------------------------------------------------- +# Add supplemental compiler warnings, and GCC visibility support. +include(CMake/VTKmCompilerExtras.cmake) + +#----------------------------------------------------------------------------- +# Configurable Options +option(VTKm_ENABLE_TESTING "Enable VTKm Testing" ON) + +option(VTKm_USE_DOUBLE_PRECISION + "Use double precision for floating point calculations" + OFF + ) +option(VTKm_USE_64BIT_IDS "Use 64-bit indices." OFF) + +if (VTKm_ENABLE_TESTING) + enable_testing() + include(CTest) +endif() + +#----------------------------------------------------------------------------- + +## Set the directory where the binaries will be stored +set( EXECUTABLE_OUTPUT_PATH + ${PROJECT_BINARY_DIR}/bin + CACHE PATH + "Directory where all executable will be stored" +) + +## Set the directory where the libraries will be stored +set( LIBRARY_OUTPUT_PATH + ${PROJECT_BINARY_DIR}/libs + CACHE PATH + "Directory where all the libraries will be stored" +) +mark_as_advanced( + EXECUTABLE_OUTPUT_PATH + LIBRARY_OUTPUT_PATH) + +include_directories( + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR} + ) + +#----------------------------------------------------------------------------- +# Add test to check for copyright statement on all source files. +if (VTKm_ENABLE_TESTING) + add_test(NAME CopyrightStatement + COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckCopyright.cmake" + ) +endif (VTKm_ENABLE_TESTING) + +#----------------------------------------------------------------------------- +# Check basic type sizes. +include(CheckTypeSize) + +check_type_size(float VTKm_SIZE_FLOAT BUILTIN_TYPES_ONLY) +check_type_size(double VTKm_SIZE_DOUBLE BUILTIN_TYPES_ONLY) +check_type_size(int VTKm_SIZE_INT BUILTIN_TYPES_ONLY) +check_type_size(long VTKm_SIZE_LONG BUILTIN_TYPES_ONLY) +check_type_size("long long" VTKm_SIZE_LONG_LONG BUILTIN_TYPES_ONLY) + +#----------------------------------------------------------------------------- +# Build the configure file. +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/vtkm/internal/Configure.h.in + ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h + @ONLY) +vtkm_install_headers( + vtkm/internal ${CMAKE_CURRENT_BINARY_DIR}/vtkm/internal/Configure.h) + + +# List of Boost features used: +# * Smart Ptr +# * Meta programming language +find_package(BoostHeaders ${VTKm_REQUIRED_BOOST_VERSION} REQUIRED) + +#----------------------------------------------------------------------------- +# Add subdirectories +add_subdirectory(vtkm) + +# Install the readme and license files. +install(FILES ${VTKm_SOURCE_DIR}/README.md + DESTINATION ${VTKm_INSTALL_CONFIG_DIR} + RENAME VTKmREADME.md + ) +install(FILES ${VTKm_SOURCE_DIR}/LICENSE.txt + DESTINATION ${VTKm_INSTALL_CONFIG_DIR} + RENAME VTKmLICENSE.txt + ) + +# Install helper configure files. +install( + FILES + ${VTKm_SOURCE_DIR}/CMake/FindBoostHeaders.cmake + DESTINATION ${VTKm_INSTALL_CMAKE_MODULE_DIR} + ) + +# Enable CPack packaging +set(CPACK_PACKAGE_DESCRIPTION_FILE ${VTKm_SOURCE_DIR}/README.md) +set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "The VTKm Toolkit") +set(CPACK_PACKAGE_NAME "VTKm") +set(CPACK_PACKAGE_VERSION_MAJOR ${VTKm_MAJOR_VERSION}) +set(CPACK_PACKAGE_VERSION_MINOR ${VTKm_MINOR_VERSION}) +set(CPACK_PACKAGE_VERSION_PATCH ${VTKm_PATCH_VERSION}) +set(CPACK_PACKAGE_FILE_NAME "VTKm-${VTKm_VERSION}") +set(CPACK_RESOURCE_FILE_LICENSE ${VTKm_SOURCE_DIR}/LICENSE.txt) +set(CPACK_RESOURCE_FILE_README ${VTKm_SOURCE_DIR}/README.md) +include(CPack)