Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into StreamingArray

Browse Source
This commit is contained in:
Christopher Sewell 2016-09-15 17:54:59 -06:00
commit d92f39df12
304 changed files with 24963 additions and 17229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
CMake/CheckCXX11Features.cmake
View File

@ -1,142 +0,0 @@
# - 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 <eike@sf-mail.de>
# 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)

8
CMake/CheckCXX11Features/cxx11-test-__func__.cpp
View File

@ -1,8 +0,0 @@
int main(void)
{
if (!__func__)
return 1;
if (!(*__func__))
return 1;
return 0;
}

12
CMake/CheckCXX11Features/cxx11-test-auto.cpp
View File

@ -1,12 +0,0 @@
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;
}

7
CMake/CheckCXX11Features/cxx11-test-auto_fail_compile.cpp
View File

@ -1,7 +0,0 @@
int main(void)
{
// must fail because there is no initializer
auto i;
return 0;
}

8
CMake/CheckCXX11Features/cxx11-test-auto_ret_type.cpp
View File

@ -1,8 +0,0 @@
auto foo(int i) -> int {
return i - 1;
}
int main()
{
return foo(1);
}

21
CMake/CheckCXX11Features/cxx11-test-class_override_final.cpp
View File

@ -1,21 +0,0 @@
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;
}

25
CMake/CheckCXX11Features/cxx11-test-class_override_final_fail_compile.cpp
View File

@ -1,25 +0,0 @@
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;
}

19
CMake/CheckCXX11Features/cxx11-test-constexpr.cpp
View File

@ -1,19 +0,0 @@
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;
}

11
CMake/CheckCXX11Features/cxx11-test-cstdint.cpp
View File

@ -1,11 +0,0 @@
#include <cstdint>
int main()
{
bool test =
(sizeof(int8_t) == 1) &&
(sizeof(int16_t) == 2) &&
(sizeof(int32_t) == 4) &&
(sizeof(int64_t) == 8);
return test ? 0 : 1;
}

10
CMake/CheckCXX11Features/cxx11-test-decltype.cpp
View File

@ -1,10 +0,0 @@
bool check_size(int i)
{
return sizeof(int) == sizeof(decltype(i));
}
int main()
{
bool ret = check_size(42);
return ret ? 0 : 1;
}

27
CMake/CheckCXX11Features/cxx11-test-initializer_list.cpp
View File

@ -1,27 +0,0 @@
#include <vector>
class seq {
public:
seq(std::initializer_list<int> list);
int length() const;
private:
std::vector<int> m_v;
};
seq::seq(std::initializer_list<int> 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;
}

5
CMake/CheckCXX11Features/cxx11-test-lambda.cpp
View File

@ -1,5 +0,0 @@
int main()
{
int ret = 0;
return ([&ret]() -> int { return ret; })();
}

7
CMake/CheckCXX11Features/cxx11-test-long_long.cpp
View File

@ -1,7 +0,0 @@
int main(void)
{
long long l;
unsigned long long ul;
return ((sizeof(l) >= 8) && (sizeof(ul) >= 8)) ? 0 : 1;
}

6
CMake/CheckCXX11Features/cxx11-test-nullptr.cpp
View File

@ -1,6 +0,0 @@
int main(void)
{
void *v = nullptr;
return v ? 1 : 0;
}

6
CMake/CheckCXX11Features/cxx11-test-nullptr_fail_compile.cpp
View File

@ -1,6 +0,0 @@
int main(void)
{
int i = nullptr;
return 1;
}

26
CMake/CheckCXX11Features/cxx11-test-regex.cpp
View File

@ -1,26 +0,0 @@
#include <algorithm>
#include <regex>
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<int>(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;
}

57
CMake/CheckCXX11Features/cxx11-test-rvalue-references.cpp
View File

@ -1,57 +0,0 @@
#include <cassert>
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;
}

14
CMake/CheckCXX11Features/cxx11-test-sizeof_member.cpp
View File

@ -1,14 +0,0 @@
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;
}

9
CMake/CheckCXX11Features/cxx11-test-sizeof_member_fail.cpp
View File

@ -1,9 +0,0 @@
struct foo {
int baz;
double bar;
};
int main(void)
{
return (sizeof(foo::bar) == 4) ? 0 : 1;
}

5
CMake/CheckCXX11Features/cxx11-test-static_assert.cpp
View File

@ -1,5 +0,0 @@
int main(void)
{
static_assert(0 < 1, "your ordering of integers is screwed");
return 0;
}

5
CMake/CheckCXX11Features/cxx11-test-static_assert_fail_compile.cpp
View File

@ -1,5 +0,0 @@
int main(void)
{
static_assert(1 < 0, "your ordering of integers is screwed");
return 0;
}

23
CMake/CheckCXX11Features/cxx11-test-variadic_templates.cpp
View File

@ -1,23 +0,0 @@
int Accumulate()
{
return 0;
}
template<typename T, typename... Ts>
int Accumulate(T v, Ts... vs)
{
return v + Accumulate(vs...);
}
template<int... Is>
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;
}

102
CMake/FindGLFW.cmake Normal file
View File

@ -0,0 +1,102 @@
##=============================================================================
##
## 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 2016 Sandia Corporation.
## Copyright 2016 UT-Battelle, LLC.
## Copyright 2016 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.
##
##=============================================================================
# Try to find EGL library and include dir.
# Once done this will define
#
# GLFW_FOUND
# GLFW_INCLUDE_DIR
# GLFW_LIBRARY
#
include(FindPackageHandleStandardArgs)
if (WIN32)
find_path( GLFW_INCLUDE_DIR
NAMES
GLFW/glfw3.h
PATHS
${PROJECT_SOURCE_DIR}/shared_external/glfw/include
${PROJECT_SOURCE_DIR}/../shared_external/glfw/include
${GLFW_LOCATION}/include
$ENV{GLFW_LOCATION}/include
$ENV{PROGRAMFILES}/GLFW/include
${GLFW_LOCATION}
$ENV{GLFW_LOCATION}
DOC "The directory where GLFW/glfw3.h resides" )
if(ARCH STREQUAL "x86")
find_library( GLFW_LIBRARY
NAMES
glfw3
PATHS
${GLFW_LOCATION}/lib
$ENV{GLFW_LOCATION}/lib
$ENV{PROGRAMFILES}/GLFW/lib
DOC "The GLFW library")
else()
find_library( GLFW_LIBRARY
NAMES
glfw3
PATHS
${GLFW_LOCATION}/lib
$ENV{GLFW_LOCATION}/lib
$ENV{PROGRAMFILES}/GLFW/lib
DOC "The GLFW library")
endif()
endif ()
if (${CMAKE_HOST_UNIX})
find_path( GLFW_INCLUDE_DIR
NAMES
GLFW/glfw3.h
PATHS
${GLFW_LOCATION}/include
$ENV{GLFW_LOCATION}/include
/usr/include
/usr/local/include
/sw/include
/opt/local/include
NO_DEFAULT_PATH
DOC "The directory where GLFW/glfw3.h resides"
)
find_library( GLFW_LIBRARY
NAMES
glfw3 glfw
PATHS
${GLFW_LOCATION}/lib
$ENV{GLFW_LOCATION}/lib
/usr/lib64
/usr/lib
/usr/local/lib64
/usr/local/lib
/sw/lib
/opt/local/lib
/usr/lib/x86_64-linux-gnu
NO_DEFAULT_PATH
DOC "The GLFW library")
endif ()
find_package_handle_standard_args(GLFW DEFAULT_MSG
GLFW_INCLUDE_DIR
GLFW_LIBRARY
)
mark_as_advanced( GLFW_INCLUDE_DIR GLFW_LIBRARY )

6
CMake/VTKmCheckCopyright.cmake
View File

@ -72,6 +72,12 @@ foreach (index RANGE ${begin_index} ${end_index})
list(GET license_lines ${index} tpl_file)
set(EXCEPTIONS ${EXCEPTIONS} ${tpl_file})
endforeach(index)
# if the build directory is in the source directory, exclude generated build
# files
find_path(BUILD_DIR CMakeCache.txt .)
get_filename_component(abs_build_dir ${BUILD_DIR} ABSOLUTE)
get_filename_component(build_dir_name ${abs_build_dir} NAME)
set(EXCEPTIONS ${EXCEPTIONS} ${build_dir_name}/*)
message("${EXCEPTIONS}")
# Gets the current year (if possible).

31
CMake/VTKmCheckSourceInBuild.cmake
View File

@ -43,11 +43,13 @@ if (NOT VTKm_SOURCE_DIR)
message(SEND_ERROR "VTKm_SOURCE_DIR not defined.")
endif (NOT VTKm_SOURCE_DIR)
function(check_directory directory)
function(check_directory directory parent_CMakeLists_contents)
message("Checking directory ${directory}...")
get_filename_component(directory_name "${directory}" NAME)
if(EXISTS "${directory}/CMakeLists.txt")
file(READ "${directory}/CMakeLists.txt" CMakeListsContents)
file(READ "${directory}/CMakeLists.txt" CMakeLists_contents)
endif()
foreach (glob_expression ${FILES_TO_CHECK})
@ -70,14 +72,23 @@ function(check_directory directory)
# Remove .in suffix. These are generally configured files that generate
# new files that are actually used in the build.
string(REGEX REPLACE ".in$" "" file_check "${file}")
string(FIND "${CMakeListsContents}" "${file_check}" position)
string(FIND "${CMakeLists_contents}" "${file_check}" position)
if(${position} LESS 0)
message(SEND_ERROR
"****************************************************************
# Check the CMakeLists.txt of the parent directory. Some sources of
# internal directories are packaged into libraries in the parent
# directory.
string(FIND "${parent_CMakeLists_contents}"
"${directory_name}/${file_check}"
position
)
if(${position} LESS 0)
message(SEND_ERROR
"****************************************************************
${file_check} is not found in ${directory}/CMakeLists.txt
This indicates that the file is not part of the build system. Thus it might be missing build targets. All such files should be explicitly handled by CMake.")
endif()
endif()
endif() # Not in parent's CMakeLists.txt
endif() # Not in CMakeLists.txt
endif() # Not skipped
endforeach (file)
endforeach(glob_expression)
@ -86,10 +97,10 @@ This indicates that the file is not part of the build system. Thus it might be m
"${directory}/*")
foreach(file ${file_list})
if(IS_DIRECTORY "${file}")
check_directory("${file}")
check_directory("${file}" "${CMakeLists_contents}")
endif()
endforeach(file)
endfunction(check_directory)
check_directory("${VTKm_SOURCE_DIR}/vtkm")
check_directory("${VTKm_SOURCE_DIR}/examples")
check_directory("${VTKm_SOURCE_DIR}/vtkm" "")
check_directory("${VTKm_SOURCE_DIR}/examples" "")

11
CMake/VTKmCompilerExtras.cmake
View File

@ -34,6 +34,10 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
set(CMAKE_COMPILER_IS_ICCXX 1)
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
set(CMAKE_COMPILER_IS_MSVCXX 1)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX)
include(CheckCXXCompilerFlag)
@ -47,9 +51,6 @@ if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_CLANGXX)
# Additional warnings for GCC/Clang
set(CMAKE_CXX_FLAGS_WARN_EXTRA "-Wno-long-long -Wcast-align -Wconversion -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()
# Additional warnings just for Clang 3.5+, and AppleClang 7+ we specify
# for all build types, since these failures to vectorize are not limited
@ -90,5 +91,7 @@ elseif(CMAKE_COMPILER_IS_ICCXX)
# to loops, the #pragma warning(disable seems to not work so we add a
# a compile define.
add_definitions("-wd13379")
elseif (CMAKE_COMPILER_IS_MSVCXX)
#enable large object support so we can have 2^32 addressable sections
list(APPEND VTKm_COMPILE_OPTIONS "/bigobj")
endif()

3
CMake/VTKmCompilerOptimizations.cmake
View File

@ -148,6 +148,9 @@ set_vectorization_flags_properties(vec_levels)
#
set(VTKm_Vectorization "none" CACHE STRING "Level of compiler vectorization support")
set_property(CACHE VTKm_Vectorization PROPERTY STRINGS ${vec_levels})
if (NOT ${VTKm_Vectorization} STREQUAL "none")
set(VTKM_VECTORIZATION_ENABLED "ON")
endif()
#
# Now that we have set up the options, lets setup the compile flags that

16
CMake/VTKmConfig.cmake.in
View File

@ -60,11 +60,21 @@ else()
set_and_check(VTKm_CMAKE_MODULE_PATH "@VTKm_SOURCE_DIR@/CMake")
endif()
set(VTKm_BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")
set(VTKm_ENABLE_CUDA "@VTKm_ENABLE_CUDA@")
set(VTKm_ENABLE_TBB "@VTKm_ENABLE_TBB@")
set(VTKm_ENABLE_OPENGL_INTEROP "@VTKm_ENABLE_OPENGL_INTEROP@")
set(VTKm_BUILD_RENDERING "@VTKm_BUILD_RENDERING@")
# Load the library exports, but only if not compiling VTK-m itself
set_and_check(VTKm_CONFIG_DIR "@PACKAGE_VTKm_INSTALL_CONFIG_DIR@")
if(NOT "${CMAKE_BINARY_DIR}" STREQUAL "@VTKm_BINARY_DIR@")
include(${VTKm_CONFIG_DIR}/VTKmTargets.cmake)
endif()
# Clear out the libraries. We will add more when loading components.
set(VTKm_LIBRARIES)
# The VTKm variables used to configure components and packages silently.
set(VTKm_CONFIGURE_QUIET "${VTKm_FIND_QUIETLY}")
set(VTKm_FIND_PACKAGE_QUIETLY "")
@ -84,6 +94,12 @@ include(VTKmMacros)
# that uses VTK-m.
set(VTKm_COMPILE_OPTIONS "@VTKm_COMPILE_OPTIONS@")
# All projects using VTK-m should include the "Base" configuration (otherwise
# nothing may compile). Make sure the Base configuration is added to
# VTKm_FIND_COMPONENTS and the component is required.
set(VTKm_FIND_COMPONENTS "Base" ${VTKm_FIND_COMPONENTS})
set(VTKm_FIND_REQUIRED_Base TRUE)
# Load the selected components
@VTKm_LOAD_COMPONENTS_COMMANDS@

128
CMake/VTKmConfigureComponents.cmake
View File

@ -39,11 +39,30 @@ set(VTKm_AVAILABLE_COMPONENTS
OpenGL
OSMesa
EGL
GLFW
Interop
Rendering
TBB
CUDA
)
#-----------------------------------------------------------------------------
# Support function for giving status messages on component configurations
#-----------------------------------------------------------------------------
set(VTKm_CONFIGURE_COMPONENT_MESSAGES "" CACHE INTERNAL "" FORCE)
function(vtkm_configure_component_message message_text)
if(NOT VTKm_CONFIGURE_QUIET)
list(FIND VTKm_CONFIGURE_COMPONENT_MESSAGES "${message_text}" in_list)
if(in_list EQUAL -1)
message(STATUS "${message_text}")
set(VTKm_CONFIGURE_COMPONENT_MESSAGES
${VTKm_CONFIGURE_COMPONENT_MESSAGES}
${message_text}
CACHE INTERNAL "" FORCE)
endif()
endif()
endfunction(vtkm_configure_component_message)
#-----------------------------------------------------------------------------
# Support function for making vtkm_configure_component<name> functions.
#-----------------------------------------------------------------------------
@ -60,9 +79,8 @@ macro(vtkm_finish_configure_component component)
foreach(var ${VTKm_FCC_DEPENDENT_VARIABLES})
if(NOT ${var})
set(VTKm_${component}_FOUND)
if(NOT VTKm_CONFIGURE_QUIET)
message(STATUS "Failed to configure VTK-m component ${component}: !${var}")
endif()
vtkm_configure_component_message(
"Failed to configure VTK-m component ${component}: !${var}")
break()
endif()
endforeach(var)
@ -84,6 +102,11 @@ macro(vtkm_configure_component_Base)
find_package(BoostHeaders ${VTKm_FIND_PACKAGE_QUIETLY} ${VTKm_REQUIRED_BOOST_VERSION})
endif()
# Set up the compiler flag optimizations
if (NOT VTKm_Vectorization_flags_added)
include(VTKmCompilerOptimizations)
endif()
vtkm_finish_configure_component(Base
DEPENDENT_VARIABLES Boost_FOUND
ADD_INCLUDES ${Boost_INCLUDE_DIRS}
@ -99,7 +122,13 @@ macro(vtkm_configure_component_Serial)
endmacro(vtkm_configure_component_Serial)
macro(vtkm_configure_component_OpenGL)
vtkm_configure_component_Base()
# OpenGL configuration "depends" on OSMesa because if OSMesa is used, then it
# (sometimes) requires its own version of OpenGL. The find_package for OpenGL
# is smart enough to configure this correctly if OSMesa is found first. Thus,
# we ensure that OSMesa is configured before OpenGL (assuming you are using
# the VTK-m configuration). However, the OpenGL configuration can still
# succeed even if the OSMesa configuration fails.
vtkm_configure_component_OSMesa()
find_package(OpenGL ${VTKm_FIND_PACKAGE_QUIETLY})
@ -111,18 +140,18 @@ macro(vtkm_configure_component_OpenGL)
endmacro(vtkm_configure_component_OpenGL)
macro(vtkm_configure_component_OSMesa)
vtkm_configure_component_OpenGL()
vtkm_configure_component_Base()
if (UNIX AND NOT APPLE)
find_package(MESA ${VTKm_FIND_PACKAGE_QUIETLY})
vtkm_finish_configure_component(OSMesa
DEPENDENT_VARIABLES VTKm_OpenGL_FOUND OSMESA_FOUND
DEPENDENT_VARIABLES OSMESA_FOUND
ADD_INCLUDES ${OSMESA_INCLUDE_DIR}
ADD_LIBRARIES ${OSMESA_LIBRARY}
)
elseif(NOT VTKm_CONFIGURE_QUIET)
message(STATUS "OSMesa not supported on this platform.")
else()
vtkm_configure_component_message("OSMesa not supported on this platform.")
endif()
endmacro(vtkm_configure_component_OSMesa)
@ -138,6 +167,18 @@ macro(vtkm_configure_component_EGL)
)
endmacro(vtkm_configure_component_EGL)
macro(vtkm_configure_component_GLFW)
vtkm_configure_component_OpenGL()
find_package(GLFW ${VTKm_FIND_PACKAGE_QUIETLY})
vtkm_finish_configure_component(GLFW
DEPENDENT_VARIABLES VTKm_OpenGL_FOUND GLFW_FOUND
ADD_INCLUDES ${GLFW_INCLUDE_DIR}
ADD_LIBRARIES ${GLFW_LIBRARY}
)
endmacro(vtkm_configure_component_GLFW)
macro(vtkm_configure_component_Interop)
vtkm_configure_component_OpenGL()
@ -150,7 +191,7 @@ macro(vtkm_configure_component_Interop)
)
#on unix/linux Glew uses pthreads, so we need to find that, and link to it
#explicitly or else in release mode we get sigsegv on launch
if (VTKm_Interop_FOUND AND UNIX)
if (VTKm_ENABLE_OPENGL_INTEROP AND UNIX)
find_package(Threads ${VTKm_FIND_PACKAGE_QUIETLY})
set(vtkm_interop_dependent_vars ${vtkm_interop_dependent_vars} CMAKE_USE_PTHREADS_INIT)
endif()
@ -158,10 +199,23 @@ macro(vtkm_configure_component_Interop)
vtkm_finish_configure_component(Interop
DEPENDENT_VARIABLES ${vtkm_interop_dependent_vars}
ADD_INCLUDES ${GLEW_INCLUDE_DIRS}
ADD_LIBRARIES ${GLEW_LIBRARIES}
ADD_LIBRARIES ${GLEW_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
)
endmacro(vtkm_configure_component_Interop)
macro(vtkm_configure_component_Rendering)
if(VTKm_BUILD_RENDERING)
vtkm_configure_component_OpenGL()
vtkm_configure_component_EGL()
vtkm_configure_component_OSMesa()
endif()
vtkm_finish_configure_component(Rendering
DEPENDENT_VARIABLES VTKm_BUILD_RENDERING VTKm_Base_FOUND
ADD_LIBRARIES vtkm_rendering
)
endmacro(vtkm_configure_component_Rendering)
macro(vtkm_configure_component_TBB)
if(VTKm_ENABLE_TBB)
vtkm_configure_component_Base()
@ -205,7 +259,12 @@ macro(vtkm_configure_component_CUDA)
if(VTKm_CUDA_FOUND)
#---------------------------------------------------------------------------
# Setup build flags for CUDA
# Setup build flags for CUDA to have C++11 support
#---------------------------------------------------------------------------
if(NOT MSVC)
list(APPEND CUDA_NVCC_FLAGS --std c++11)
endif()
#---------------------------------------------------------------------------
# Populates CUDA_NVCC_FLAGS with the best set of flags to compile for a
# given GPU architecture. The majority of developers should leave the
@ -242,27 +301,34 @@ macro(vtkm_configure_component_CUDA)
#detect what the propery is set too
if(VTKm_CUDA_Architecture STREQUAL "native")
#run execute_process to do auto_detection
set(command ${CUDA_NVCC_EXECUTABLE})
set(args "-ccbin" "${CMAKE_CXX_COMPILER}" "--run" "${VTKm_CMAKE_MODULE_PATH}/VTKmDetectCUDAVersion.cxx")
execute_process(
COMMAND ${command} ${args}
RESULT_VARIABLE ran_properly
OUTPUT_VARIABLE run_output
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
if(NOT VTKM_CUDA_NATIVE_EXE_PROCESS_RAN)
if(ran_properly EQUAL 0)
#find the position of the "--generate-code" output. With some compilers such as
#msvc we get compile output plus run output. So we need to strip out just the
#run output
string(FIND "${run_output}" "--generate-code" position)
string(SUBSTRING "${run_output}" ${position} -1 run_output)
set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} ${run_output}")
else()
set(VTKm_CUDA_Architecture "fermi")
if(NOT VTKm_CONFIGURE_QUIET)
message(STATUS "Unable to run \"${CUDA_NVCC_EXECUTABLE}\" to autodetect GPU architecture."
"Falling back to fermi, please manually specify if you want something else.")
#run execute_process to do auto_detection
if(CMAKE_GENERATOR MATCHES "Visual Studio")
set(args "-ccbin" "${CMAKE_CXX_COMPILER}" "--run" "${VTKm_CMAKE_MODULE_PATH}/VTKmDetectCUDAVersion.cxx")
else()
set(args "-ccbin" "${CUDA_HOST_COMPILER}" "--run" "${VTKm_CMAKE_MODULE_PATH}/VTKmDetectCUDAVersion.cxx")
endif()
execute_process(
COMMAND ${CUDA_NVCC_EXECUTABLE} ${args}
RESULT_VARIABLE ran_properly
OUTPUT_VARIABLE run_output
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
if(ran_properly EQUAL 0)
#find the position of the "--generate-code" output. With some compilers such as
#msvc we get compile output plus run output. So we need to strip out just the
#run output
string(FIND "${run_output}" "--generate-code" position)
string(SUBSTRING "${run_output}" ${position} -1 run_output)
set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} ${run_output}")
set(VTKM_CUDA_NATIVE_EXE_PROCESS_RAN TRUE CACHE INTERNAL
"We have correctly detected the device type(s) for cuda[native]")
else()
set(VTKm_CUDA_Architecture "fermi")
vtkm_configure_component_message(
"Unable to run \"${CUDA_NVCC_EXECUTABLE}\" to autodetect GPU architecture.
Falling back to fermi, please manually specify if you want something else.")
endif()
endif()
endif()

196
CMake/VTKmMacros.cmake
View File

@ -19,6 +19,7 @@
##============================================================================
include(CMakeParseArguments)
include(GenerateExportHeader)
# Utility to build a kit name from the current directory.
function(vtkm_get_kit_name kitvar)
@ -73,17 +74,9 @@ endfunction(vtkm_setup_nvcc_flags)
function(vtkm_setup_msvc_properties target )
#disable MSVC CRT and SCL warnings as they recommend using non standard
#c++ extensions
set_property(TARGET ${target}
APPEND PROPERTY COMPILE_DEFINITIONS
"_SCL_SECURE_NO_WARNINGS"
"_CRT_SECURE_NO_WARNINGS"
)
target_compile_definitions(${target} PRIVATE "_SCL_SECURE_NO_WARNINGS"
"_CRT_SECURE_NO_WARNINGS")
#enable large object support so we can have 2^32 addressable sections
set_property(TARGET ${target}
APPEND PROPERTY COMPILE_FLAGS
"/bigobj"
)
endfunction(vtkm_setup_msvc_properties)
# Builds a source file and an executable that does nothing other than
@ -120,21 +113,22 @@ function(vtkm_add_header_build_test name dir_prefix use_cuda)
list(APPEND CUDA_NVCC_INCLUDE_ARGS_USER -isystem ${dir})
endforeach()
cuda_add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
cuda_add_library(TestBuild_${name} STATIC ${cxxfiles} ${hfiles})
elseif (${cxxfiles_len} GREATER 0)
add_library(TestBuild_${name} ${cxxfiles} ${hfiles})
if(VTKm_EXTRA_COMPILER_WARNINGS)
set_property(TARGET ${test_prog}
APPEND PROPERTY COMPILE_FLAGS
${CMAKE_CXX_FLAGS_WARN_EXTRA}
)
endif(VTKm_EXTRA_COMPILER_WARNINGS)
add_library(TestBuild_${name} STATIC ${cxxfiles} ${hfiles})
target_include_directories(TestBuild_${name} PRIVATE ${VTKm_INCLUDE_DIRS})
endif ()
target_link_libraries(TestBuild_${name} ${VTKm_LIBRARIES})
set_source_files_properties(${hfiles}
PROPERTIES HEADER_FILE_ONLY TRUE
)
# Send the libraries created for test builds to their own directory so as to
# not polute the directory with useful libraries.
set_target_properties(TestBuild_${name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}/testbuilds
LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}/testbuilds
RUNTIME_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}/testbuilds
)
endfunction(vtkm_add_header_build_test)
function(vtkm_install_headers dir_prefix)
@ -241,11 +235,12 @@ endfunction(vtkm_pyexpander_generated_file)
# vtkm_unit_tests(
# SOURCES <source_list>
# LIBRARIES <dependent_library_list>
# TEST_ARGS <argument_list>
# )
function(vtkm_unit_tests)
set(options CUDA)
set(oneValueArgs)
set(multiValueArgs SOURCES LIBRARIES)
set(multiValueArgs SOURCES LIBRARIES TEST_ARGS)
cmake_parse_arguments(VTKm_UT
"${options}" "${oneValueArgs}" "${multiValueArgs}"
${ARGN}
@ -286,8 +281,7 @@ function(vtkm_unit_tests)
#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_INCLUDE_DIRS} )
target_include_directories(${test_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${test_prog} ${VTKm_LIBRARIES})
@ -297,17 +291,10 @@ function(vtkm_unit_tests)
vtkm_setup_msvc_properties(${test_prog})
endif()
if(VTKm_EXTRA_COMPILER_WARNINGS)
set_property(TARGET ${test_prog}
APPEND PROPERTY COMPILE_FLAGS
${CMAKE_CXX_FLAGS_WARN_EXTRA}
)
endif(VTKm_EXTRA_COMPILER_WARNINGS)
foreach (test ${VTKm_UT_SOURCES})
get_filename_component(tname ${test} NAME_WE)
add_test(NAME ${tname}
COMMAND ${test_prog} ${tname}
COMMAND ${test_prog} ${tname} ${VTKm_UT_TEST_ARGS}
)
set_tests_properties("${tname}" PROPERTIES TIMEOUT ${timeout})
endforeach (test)
@ -422,9 +409,7 @@ function(vtkm_worklet_unit_tests device_adapter)
else()
add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
endif()
set_property(TARGET ${test_prog} APPEND PROPERTY
INCLUDE_DIRECTORIES ${VTKm_INCLUDE_DIRS}
)
target_include_directories(${test_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${test_prog} ${VTKm_LIBRARIES})
#add the specific compile options for this executable
@ -446,18 +431,8 @@ function(vtkm_worklet_unit_tests device_adapter)
vtkm_setup_msvc_properties(${test_prog})
endif()
#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}" )
target_compile_definitions(${test_prog} PRIVATE "VTKM_DEVICE_ADAPTER=${device_adapter}")
endif()
endfunction(vtkm_worklet_unit_tests)
@ -562,8 +537,7 @@ function(vtkm_benchmarks device_adapter)
set_source_files_properties(${benchmark_headers}
PROPERTIES HEADER_FILE_ONLY TRUE)
set_property(TARGET ${benchmark_prog} APPEND PROPERTY
INCLUDE_DIRECTORIES ${VTKm_INCLUDE_DIRS} )
target_include_directories(${benchmark_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${benchmark_prog} ${VTKm_LIBRARIES})
if(MSVC)
@ -573,19 +547,8 @@ function(vtkm_benchmarks device_adapter)
#add the specific compile options for this executable
target_compile_options(${benchmark_prog} PRIVATE ${VTKm_COMPILE_OPTIONS})
#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 ${benchmark_prog}
APPEND PROPERTY COMPILE_FLAGS ${CMAKE_CXX_FLAGS_WARN_EXTRA} )
endif()
#set the device adapter on the executable
set_property(TARGET ${benchmark_prog}
APPEND
PROPERTY COMPILE_DEFINITIONS "VTKM_DEVICE_ADAPTER=${device_adapter}" )
target_compile_definitions(${benchmark_prog} PRIVATE "VTKM_DEVICE_ADAPTER=${device_adapter}")
endforeach()
@ -597,6 +560,125 @@ function(vtkm_benchmarks device_adapter)
endfunction(vtkm_benchmarks)
# Given a list of *.cxx source files that during configure time are deterimined
# to have CUDA code, wrap the sources in *.cu files so that they get compiled
# with nvcc.
function(vtkm_wrap_sources_for_cuda cuda_source_list_var)
set(original_sources ${ARGN})
set(cuda_sources)
foreach(source_file ${original_sources})
get_filename_component(source_name ${source_file} NAME_WE)
get_filename_component(source_file_path ${source_file} ABSOLUTE)
set(wrapped_file ${CMAKE_CURRENT_BINARY_DIR}/${source_name}.cu)
configure_file(
${VTKm_SOURCE_DIR}/CMake/WrapCUDASource.cu.in
${wrapped_file}
@ONLY)
list(APPEND cuda_sources ${wrapped_file})
endforeach(source_file)
set_source_files_properties(${original_sources}
PROPERTIES HEADER_FILE_ONLY TRUE
)
set(${cuda_source_list_var} ${cuda_sources} PARENT_SCOPE)
endfunction(vtkm_wrap_sources_for_cuda)
set(VTKM_HAS_AT_LEAST_ONE_LIBRARY FALSE CACHE INTERNAL "" FORCE)
# Add a VTK-m library. The name of the library will match the "kit" name
# (e.g. vtkm_rendering) unless the NAME argument is given.
#
# vtkm_library(
# [NAME <name>]
# SOURCES <source_list>
# [CUDA]
# [WRAP_FOR_CUDA <source_list>]
# )
function(vtkm_library)
set(options CUDA)
set(oneValueArgs NAME)
set(multiValueArgs SOURCES WRAP_FOR_CUDA)
cmake_parse_arguments(VTKm_LIB
"${options}" "${oneValueArgs}" "${multiValueArgs}"
${ARGN}
)
vtkm_get_kit_name(kit dir_prefix)
if(VTKm_LIB_NAME)
set(lib_name ${VTKm_LIB_NAME})
else()
set(lib_name ${kit})
endif()
if(VTKm_LIB_CUDA)
vtkm_setup_nvcc_flags(old_nvcc_flags old_cxx_flags)
vtkm_wrap_sources_for_cuda(cuda_sources ${VTKm_LIB_WRAP_FOR_CUDA})
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_add_library(${lib_name} ${VTKm_LIB_SOURCES} ${cuda_sources})
set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
set(CMAKE_CXX_FLAGS ${old_cxx_flags})
else()
add_library(${lib_name} ${VTKm_LIB_SOURCES})
endif()
#do it as a property value so we don't pollute the include_directories
#for any other targets
set_property(TARGET ${lib_name} APPEND PROPERTY
INCLUDE_DIRECTORIES ${VTKm_INCLUDE_DIRS} )
target_link_libraries(${lib_name} ${VTKm_LIBRARIES})
set(cxx_args ${VTKm_COMPILE_OPTIONS})
separate_arguments(cxx_args)
target_compile_options(${lib_name} PRIVATE ${cxx_args})
# Make sure libraries go to lib directory and dll go to bin directory.
# Mostly important on Windows.
set_target_properties(${lib_name} PROPERTIES
ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
)
if(MSVC)
vtkm_setup_msvc_properties(${lib_name})
endif()
if(VTKm_EXTRA_COMPILER_WARNINGS)
set(cxx_args ${CMAKE_CXX_FLAGS_WARN_EXTRA})
separate_arguments(cxx_args)
target_compile_options(${lib_name}
PRIVATE ${cxx_args}
)
endif(VTKm_EXTRA_COMPILER_WARNINGS)
generate_export_header(${lib_name})
#generate_export_header creates the header in CMAKE_CURRENT_BINARY_DIR.
#The build expects it in the install directory.
file(COPY
${CMAKE_CURRENT_BINARY_DIR}/${lib_name}_export.h
DESTINATION
${CMAKE_BINARY_DIR}/${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix}
)
install(TARGETS ${lib_name}
EXPORT ${VTKm_EXPORT_NAME}
ARCHIVE DESTINATION ${VTKm_INSTALL_LIB_DIR}
LIBRARY DESTINATION ${VTKm_INSTALL_LIB_DIR}
RUNTIME DESTINATION ${VTKm_INSTALL_BIN_DIR}
)
vtkm_install_headers("${dir_prefix}"
${CMAKE_BINARY_DIR}/${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix}/${lib_name}_export.h
)
set(VTKM_HAS_AT_LEAST_ONE_LIBRARY TRUE CACHE INTERNAL "" FORCE)
endfunction(vtkm_library)
# 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

1
CMake/WrapCUDASource.cu.in Normal file
View File

@ -0,0 +1 @@
#include "@source_file_path@"

82
CMakeLists.txt Executable file → Normal file
View File

@ -34,6 +34,7 @@ endif()
#setup policy rules for CMake 3.3 while we have a minimum required of 2.8.X
if(POLICY CMP0063)
cmake_policy(SET CMP0058 NEW)#All dependencies on built targets are declared
cmake_policy(SET CMP0063 NEW)#Honor visibility properties for all targets
endif()
@ -45,9 +46,13 @@ 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_CONFIG_DIR "lib")
set(VTKm_INSTALL_LIB_DIR "lib")
set(VTKm_INSTALL_BIN_DIR "bin")
set(VTKm_INSTALL_CMAKE_MODULE_DIR "share/vtkm/cmake")
set(VTKm_EXPORT_NAME "VTKmTargets")
set(VTKm_REQUIRED_BOOST_VERSION "1.48")
set(VTKm_CMAKE_MODULE_PATH ${VTKm_SOURCE_DIR}/CMake)
@ -69,14 +74,18 @@ if(NOT VTKm_Base_FOUND)
endif()
#-----------------------------------------------------------------------------
# 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 flag to enable C++11 support.
if (NOT CMAKE_VERSION VERSION_LESS "3.1")
option(VTKm_ENABLE_CXX11 "Build VTKm using C++11" ON)
else()
set(VTKm_ENABLE_CXX11 OFF)
endif()
# If the user has requested C++11, propagate that information to CMake
if (VTKm_ENABLE_CXX11)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED True)
set(CMAKE_CXX_EXTENSIONS False)
endif()
#-----------------------------------------------------------------------------
# Add supplemental compiler warnings, and GCC visibility support.
@ -107,6 +116,9 @@ option(VTKm_USE_DOUBLE_PRECISION
)
option(VTKm_USE_64BIT_IDS "Use 64-bit indices." ON)
option(BUILD_SHARED_LIBS "Build VTK-m with shared libraries" ON)
set(VTKm_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
if (VTKm_ENABLE_TESTING)
enable_testing()
include(CTest)
@ -129,7 +141,7 @@ endif (VTKm_ENABLE_TBB)
if (VTKm_ENABLE_CUDA)
vtkm_configure_component_CUDA()
if(NOT VTKm_CUDA_FOUND)
message(SEND_ERROR "Could not load CUDA configuration. If CUDA is not available, turn off VTKm_ENABLE_TBB.")
message(SEND_ERROR "Could not load CUDA configuration. If CUDA is not available, turn off VTKm_ENABLE_CUDA.")
endif()
endif (VTKm_ENABLE_CUDA)
@ -144,7 +156,7 @@ set( EXECUTABLE_OUTPUT_PATH
## Set the directory where the libraries will be stored
set( LIBRARY_OUTPUT_PATH
${PROJECT_BINARY_DIR}/libs
${PROJECT_BINARY_DIR}/lib
CACHE PATH
"Directory where all the libraries will be stored"
)
@ -225,12 +237,6 @@ if (VTKm_BUILD_DOCUMENTATION)
vtkm_build_documentation()
endif()
#-----------------------------------------------------------------------------
# Build examples
if(VTKm_BUILD_EXAMPLES)
add_subdirectory(examples)
endif(VTKm_BUILD_EXAMPLES)
#-----------------------------------------------------------------------------
# Ready files for find_package
include(CMakePackageConfigHelpers)
@ -239,7 +245,16 @@ string(REPLACE ";" " " VTKm_AVAILABLE_COMPONENTS_LIST
"${VTKm_AVAILABLE_COMPONENTS}"
)
set(VTKm_LOAD_COMPONENTS_COMMANDS "
set(VTKm_LOAD_COMPONENTS_COMMANDS "# Clear out old FOUND flags")
foreach(component ${VTKm_AVAILABLE_COMPONENTS})
set(VTKm_LOAD_COMPONENTS_COMMANDS "${VTKm_LOAD_COMPONENTS_COMMANDS}
set(VTKm_${component}_FOUND)"
)
endforeach(component)
set(VTKm_LOAD_COMPONENTS_COMMANDS "${VTKm_LOAD_COMPONENTS_COMMANDS}
# Load each component selected in find_package
foreach(comp \${VTKm_FIND_COMPONENTS})")
foreach(component ${VTKm_AVAILABLE_COMPONENTS})
@ -270,7 +285,12 @@ configure_package_config_file(
${VTKm_SOURCE_DIR}/CMake/VTKmConfig.cmake.in
${VTKm_BINARY_DIR}/${VTKm_INSTALL_CONFIG_DIR}/VTKmConfig.cmake
INSTALL_DESTINATION ${VTKm_INSTALL_CONFIG_DIR}
PATH_VARS VTKm_INSTALL_INCLUDE_DIR VTKm_INSTALL_CMAKE_MODULE_DIR
PATH_VARS
VTKm_INSTALL_INCLUDE_DIR
VTKm_INSTALL_CONFIG_DIR
VTKm_INSTALL_LIB_DIR
VTKm_INSTALL_BIN_DIR
VTKm_INSTALL_CMAKE_MODULE_DIR
)
write_basic_package_version_file(
@ -314,7 +334,23 @@ install(
DESTINATION ${VTKm_INSTALL_CMAKE_MODULE_DIR}
)
# Create and install exports for external projects
if(${VTKM_HAS_AT_LEAST_ONE_LIBRARY})
export(EXPORT ${VTKm_EXPORT_NAME}
FILE ${CMAKE_BINARY_DIR}/${VTKm_INSTALL_CONFIG_DIR}/VTKmTargets.cmake
)
install(EXPORT ${VTKm_EXPORT_NAME}
DESTINATION ${VTKm_INSTALL_LIB_DIR}
FILE VTKmTargets.cmake
)
else() # No libraries built
file(WRITE ${CMAKE_BINARY_DIR}/${VTKm_INSTALL_CONFIG_DIR}/VTKmTargets.cmake
"# This build of VTK-m has no libraries to export targets for"
)
install(FILES ${CMAKE_BINARY_DIR}/${VTKm_INSTALL_CONFIG_DIR}/VTKmTargets.cmake
DESTINATION ${VTKm_INSTALL_LIB_DIR}
)
endif()
# Enable CPack packaging
set(CPACK_PACKAGE_DESCRIPTION_FILE ${VTKm_SOURCE_DIR}/README.md)
@ -327,3 +363,9 @@ 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)
#-----------------------------------------------------------------------------
# Build examples
if(VTKm_BUILD_EXAMPLES)
add_subdirectory(examples)
endif(VTKm_BUILD_EXAMPLES)

2
docs/CodingConventions.md
View File

@ -110,7 +110,7 @@ a tab stop is, so it is better to not use them at all.
+ Namespaces should not be brought into global scope or the scope of any VTK-M package names- pace with the “using” keyword. It should also be avoided in class, method, and function scopes (fully qualified namespace references are preferred).
+ All code must be valid by the C++03 and C++11 specifications. It must also compile on older compilers that support C++98. Code that uses language features not available in C++98 must have a second implementation that works around the limitations of C++98. The VTKM_FORCE_ANSI turns on a compiler check for ANSI compatibility in gcc and clang compilers.
+ All code must be valid by the C++03 and C++11 specifications. It must also compile on older compilers that support C++98. Code that uses language features not available in C++11 must have a second implementation that works for C++98. The VTKm_ENABLE_CXX11 turns on C++11 compiler flags for gcc, clang, intel and MSVC compilers.
+ Limit all lines to 80 characters whenever possible.

31
docs/DesignDecisions.md
View File

@ -1,31 +0,0 @@
### Design Decisions ###
A quick list of what the final design of vtkm should look like:
Code Layout:
```
vtkm/
cont/
- vtkm::cont::ArrayHandle
- vtkm::cont::CellSet
- vtkm::cont::DataSet
interop/
- OpenGL interop classes
- VTK interop classes
cuda/
filters/
- vtkm::filter::ThresholdFilter
- vtkm::filter::ContourFilter
- Mutators?
exec/
cuda/
worklets/
- vtkm::worklet::WorkletMapField
- vtkm::worklet::WorkletMapCell
```

5
examples/CMakeLists.txt
View File

@ -19,8 +19,9 @@
## this software.
##
##=============================================================================
#specify that all examples should be quiet in the detection of components
set(VTKm_CONFIGURE_QUIET TRUE)
#add the directory that contains the VTK-m config file to the cmake
#path so that our examples can find VTK-m
set(CMAKE_PREFIX_PATH ${VTKm_BINARY_DIR}/${VTKm_INSTALL_CONFIG_DIR})
add_subdirectory(clipping)
add_subdirectory(demo)

21
examples/clipping/CMakeLists.txt
View File

@ -19,20 +19,17 @@
## this software.
##
##=============================================================================
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB
)
add_executable(Clipping_SERIAL Clipping.cxx)
target_include_directories(Clipping_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Clipping_SERIAL ${VTKm_LIBRARIES})
target_compile_options(Clipping_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
set_property(
TARGET Clipping_SERIAL
APPEND
PROPERTY COMPILE_DEFINITIONS "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_compile_definitions(Clipping_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
if(VTKm_CUDA_FOUND)
set (cudaSource "${CMAKE_CURRENT_BINARY_DIR}/Clipping.cu")
@ -61,8 +58,6 @@ if(VTKm_TBB_FOUND)
target_include_directories(Clipping_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Clipping_TBB ${VTKm_LIBRARIES})
target_compile_options(Clipping_TBB PRIVATE PRIVATE ${VTKm_COMPILE_OPTIONS})
set_property(
TARGET Clipping_TBB
APPEND
PROPERTY COMPILE_DEFINITIONS "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
target_compile_definitions(Clipping_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
endif()

10
examples/clipping/Clipping.cxx
View File

@ -63,14 +63,15 @@ int main(int argc, char *argv[])
input.GetField(0);
vtkm::Float32 clipValue = boost::lexical_cast<vtkm::Float32>(argv[argc - 2]);
vtkm::worklet::Clip<DeviceAdapter> clip;
vtkm::worklet::Clip clip;
vtkm::cont::Timer<DeviceAdapter> total;
vtkm::cont::Timer<DeviceAdapter> timer;
vtkm::cont::CellSetExplicit<> outputCellSet =
clip.Run(input.GetCellSet(0),
scalarField.GetData().ResetTypeList(vtkm::TypeListTagScalarAll()),
clipValue);
clipValue,
DeviceAdapter());
vtkm::Float64 clipTime = timer.GetElapsedTime();
vtkm::cont::DataSet output;
@ -78,7 +79,7 @@ int main(int argc, char *argv[])
timer.Reset();
vtkm::cont::DynamicArrayHandle coords =
clip.ProcessField(input.GetCoordinateSystem(0).GetData());
clip.ProcessField(input.GetCoordinateSystem(0), DeviceAdapter());
vtkm::Float64 processCoordinatesTime = timer.GetElapsedTime();
output.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coords));
@ -91,7 +92,8 @@ int main(int argc, char *argv[])
continue; // clip only supports point fields for now.
}
vtkm::cont::DynamicArrayHandle data =
clip.ProcessField(inField.GetData().ResetTypeList(vtkm::TypeListTagAll()));
clip.ProcessField(inField.GetData().ResetTypeList(vtkm::TypeListTagAll()),
DeviceAdapter());
output.AddField(vtkm::cont::Field(inField.GetName(),
vtkm::cont::Field::ASSOC_POINTS, data));
}

18
examples/demo/CMakeLists.txt
View File

@ -19,9 +19,14 @@
## this software.
##
##=============================================================================
vtkm_configure_component_OSMESA()
if(VTKm_OSMESA_FOUND)
#Find the VTK-m package
find_package(VTKm QUIET REQUIRED
OPTIONAL_COMPONENTS Serial CUDA TBB OSMesa Rendering
)
if(VTKm_OSMesa_FOUND AND VTKm_Rendering_FOUND)
if(VTKm_CUDA_FOUND)
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
@ -30,8 +35,17 @@ if(VTKm_OSMESA_FOUND)
add_executable(Demo Demo.cxx)
endif()
#need to setup the default device adapter.
target_include_directories(Demo PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Demo ${VTKm_LIBRARIES})
target_compile_options(Demo PRIVATE ${VTKm_COMPILE_OPTIONS})
#when we are using TBB pass in the default device adapter as
#a compile definition to make sure we build with TBB selected
if(VTKm_TBB_FOUND)
target_compile_definitions(Demo
PRIVATE "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
endif()
endif()

3
examples/demo/Demo.cu
View File

@ -18,4 +18,7 @@
// this software.
//============================================================================
//Define the CUDA device adapter as being the default
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_CUDA
#include "Demo.cxx"

89
examples/demo/Demo.cxx
View File

@ -20,10 +20,10 @@
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/rendering/Actor.h>
#include <vtkm/rendering/CanvasOSMesa.h>
#include <vtkm/rendering/MapperGL.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/MapperRayTracer.h>
#include <vtkm/rendering/Scene.h>
#include <vtkm/rendering/View.h>
#include <vtkm/rendering/View3D.h>
#include <vtkm/cont/DeviceAdapter.h>
#include <vtkm/cont/testing/Testing.h>
@ -34,6 +34,19 @@
#include <iostream>
void makeScene(const vtkm::cont::DataSet &inputData,
const vtkm::rendering::ColorTable &colorTable,
const std::string &fieldName,
vtkm::rendering::Scene &scene)
{
scene.AddActor(vtkm::rendering::Actor(inputData.GetCellSet(),
inputData.GetCoordinateSystem(),
inputData.GetField(fieldName),
colorTable));
}
// This example reads an input vtk file specified on the command-line (or generates a default
// input data set if none is provided), uses VTK-m's rendering engine to render it to an
// output file using OS Mesa, instantiates an isosurface filter using VTK-m's filter
@ -65,71 +78,67 @@ int main(int argc, char* argv[])
fieldName = "SCALARS:pointvar";
}
typedef vtkm::rendering::MapperGL< > Mapper;
typedef vtkm::rendering::CanvasOSMesa Canvas;
typedef vtkm::rendering::MapperRayTracer<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> Mapper;
typedef vtkm::rendering::CanvasRayTracer Canvas;
// Set up a camera for rendering the input data
const vtkm::cont::CoordinateSystem coords = inputData.GetCoordinateSystem();
Mapper mapper;
vtkm::rendering::Camera3D &camera = mapper.GetCamera();
vtkm::Float64 coordsBounds[6];
coords.GetBounds(coordsBounds,VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
vtkm::rendering::Camera camera = vtkm::rendering::Camera();
//Set3DView
vtkm::Bounds coordsBounds = coords.GetBounds(VTKM_DEFAULT_DEVICE_ADAPTER_TAG());
camera.ResetToBounds(coordsBounds);
vtkm::Vec<vtkm::Float32,3> totalExtent;
totalExtent[0] = vtkm::Float32(coordsBounds[1] - coordsBounds[0]);
totalExtent[1] = vtkm::Float32(coordsBounds[3] - coordsBounds[2]);
totalExtent[2] = vtkm::Float32(coordsBounds[5] - coordsBounds[4]);
totalExtent[0] = vtkm::Float32(coordsBounds.X.Max - coordsBounds.X.Min);
totalExtent[1] = vtkm::Float32(coordsBounds.Y.Max - coordsBounds.Y.Min);
totalExtent[2] = vtkm::Float32(coordsBounds.Z.Max - coordsBounds.Z.Min);
vtkm::Float32 mag = vtkm::Magnitude(totalExtent);
vtkm::Normalize(totalExtent);
camera.LookAt = totalExtent * (mag * .5f);
camera.Up = vtkm::make_Vec(0.f, 1.f, 0.f);
camera.NearPlane = 1.f;
camera.FarPlane = 100.f;
camera.FieldOfView = 60.f;
camera.Height = 512;
camera.Width = 512;
camera.Position = totalExtent * (mag * 2.f);
camera.SetLookAt(totalExtent * (mag * .5f));
camera.SetViewUp(vtkm::make_Vec(0.f, 1.f, 0.f));
camera.SetClippingRange(1.f, 100.f);
camera.SetFieldOfView(60.f);
camera.SetPosition(totalExtent * (mag * 2.f));
vtkm::rendering::ColorTable colorTable("thermal");
mapper.SetActiveColorTable(colorTable);
mapper.SetCamera(camera);
// Create a scene for rendering the input data
vtkm::rendering::Scene3D scene;
vtkm::rendering::Scene scene;
vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
vtkm::rendering::CanvasOSMesa surface(512,512,bg);
scene.Actors.push_back(vtkm::rendering::Actor(inputData.GetCellSet(),
inputData.GetCoordinateSystem(),
inputData.GetField(fieldName),
colorTable));
Canvas canvas(512,512);
makeScene(inputData, colorTable, fieldName, scene);
// Create a view and use it to render the input data using OS Mesa
vtkm::rendering::View3D<Mapper, Canvas> view1(scene,
vtkm::rendering::View3D view(scene,
mapper,
surface,
canvas,
camera,
bg);
view1.Initialize();
view1.Paint();
view1.SaveAs("demo_input.pnm");
view.Initialize();
view.Paint();
view.SaveAs("demo_input.pnm");
// Create an isosurface filter
vtkm::filter::MarchingCubes filter;
filter.SetGenerateNormals(false);
filter.SetMergeDuplicatePoints(false);
filter.SetIsoValue(isovalue);
vtkm::filter::DataSetResult result = filter.Execute( inputData,
vtkm::filter::ResultDataSet result = filter.Execute( inputData,
inputData.GetField(fieldName) );
filter.MapFieldOntoOutput(result, inputData.GetField(fieldName));
vtkm::cont::DataSet& outputData = result.GetDataSet();
// Render a separate image with the output isosurface
std::cout << "about to render the results of the MarchingCubes filter" << std::endl;
scene.Actors.clear();
scene.Actors.push_back(vtkm::rendering::Actor(outputData.GetCellSet(),
outputData.GetCoordinateSystem(),
outputData.GetField(fieldName),
colorTable));
vtkm::rendering::Scene scene2;
makeScene(outputData, colorTable, fieldName, scene2);
vtkm::rendering::View3D< Mapper, Canvas> view2(scene,
vtkm::rendering::View3D view2(scene2,
mapper,
surface,
canvas,
camera,
bg);
view2.Initialize();
view2.Paint();

1
examples/dynamic_dispatcher/CMakeLists.txt
View File

@ -24,3 +24,4 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
add_executable(DynamicDispatcherExample main.cxx)
target_include_directories(DynamicDispatcherExample PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(DynamicDispatcherExample ${VTKm_LIBRARIES})
target_compile_options(DynamicDispatcherExample PRIVATE ${VTKm_COMPILE_OPTIONS})

11
examples/hello_world/CMakeLists.txt
View File

@ -20,13 +20,12 @@
##
##=============================================================================
find_package(GLUT)
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB OpenGL Interop
)
vtkm_configure_component_OpenGL()
vtkm_configure_component_Interop()
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
find_package(GLUT)
if(VTKm_Interop_FOUND AND VTKm_OpenGL_FOUND AND GLUT_FOUND)
include_directories(${CMAKE_CURRENT_SOURCE_DIR})

2
examples/hello_world/HelloWorld.cxx
View File

@ -180,7 +180,7 @@ struct HelloVTKMInterop
//global static so that glut callback can access it
typedef VTKM_DEFAULT_DEVICE_ADAPTER_TAG DeviceAdapter;
HelloVTKMInterop< DeviceAdapter, vtkm::Float32 >* helloWorld = NULL;
HelloVTKMInterop< DeviceAdapter, vtkm::Float32 >* helloWorld = nullptr;
// Render the output using simple OpenGL
void run()

10
examples/isosurface/CMakeLists.txt
View File

@ -20,12 +20,12 @@
##
##=============================================================================
find_package(GLUT)
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB OpenGL
)
vtkm_configure_component_OpenGL()
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
find_package(GLUT)
if(VTKm_OpenGL_FOUND AND GLUT_FOUND)
add_executable(IsosurfaceUniformGrid_SERIAL IsosurfaceUniformGrid.cxx quaternion.h)

14
examples/isosurface/IsosurfaceUniformGrid.cxx
View File

@ -66,11 +66,11 @@ public:
typedef _1 InputDomain;
const vtkm::Id xdim, ydim, zdim;
const vtkm::FloatDefault xmin, ymin, zmin, xmax, ymax, zmax;
const vtkm::Float32 xmin, ymin, zmin, xmax, ymax, zmax;
const vtkm::Id cellsPerLayer;
VTKM_CONT_EXPORT
TangleField(const vtkm::Id3 dims, const vtkm::FloatDefault mins[3], const vtkm::FloatDefault maxs[3]) : xdim(dims[0]), ydim(dims[1]), zdim(dims[2]),
TangleField(const vtkm::Id3 dims, const vtkm::Float32 mins[3], const vtkm::Float32 maxs[3]) : xdim(dims[0]), ydim(dims[1]), zdim(dims[2]),
xmin(mins[0]), ymin(mins[1]), zmin(mins[2]), xmax(maxs[0]), ymax(maxs[1]), zmax(maxs[2]), cellsPerLayer((xdim) * (ydim)) { };
VTKM_EXEC_EXPORT
@ -80,9 +80,9 @@ public:
const vtkm::Id y = (vertexId / (xdim)) % (ydim);
const vtkm::Id z = vertexId / cellsPerLayer;
const vtkm::FloatDefault fx = static_cast<vtkm::FloatDefault>(x) / static_cast<vtkm::FloatDefault>(xdim-1);
const vtkm::FloatDefault fy = static_cast<vtkm::FloatDefault>(y) / static_cast<vtkm::FloatDefault>(xdim-1);
const vtkm::FloatDefault fz = static_cast<vtkm::FloatDefault>(z) / static_cast<vtkm::FloatDefault>(xdim-1);
const vtkm::Float32 fx = static_cast<vtkm::Float32>(x) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 fy = static_cast<vtkm::Float32>(y) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 fz = static_cast<vtkm::Float32>(z) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 xx = 3.0f*(xmin+(xmax-xmin)*(fx));
const vtkm::Float32 yy = 3.0f*(ymin+(ymax-ymin)*(fy));
@ -100,8 +100,8 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
const vtkm::Id3 vdims(dims[0] + 1, dims[1] + 1, dims[2] + 1);
vtkm::FloatDefault mins[3] = {-1.0f, -1.0f, -1.0f};
vtkm::FloatDefault maxs[3] = {1.0f, 1.0f, 1.0f};
vtkm::Float32 mins[3] = {-1.0f, -1.0f, -1.0f};
vtkm::Float32 maxs[3] = {1.0f, 1.0f, 1.0f};
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
vtkm::cont::ArrayHandleCounting<vtkm::Id> vertexCountImplicitArray(0, 1, vdims[0]*vdims[1]*vdims[2]);

9
examples/multi_backend/CMakeLists.txt
View File

@ -20,11 +20,10 @@
##
##=============================================================================
find_package(GLUT)
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB
)
if(VTKm_CUDA_FOUND)
# Cuda compiles do not respect target_include_directories

125
examples/multi_backend/MultiBackend.cxx
View File

@ -29,6 +29,10 @@
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>
#include <vtkm/cont/tbb/DeviceAdapterTBB.h>
#include <vtkm/cont/DeviceAdapterSerial.h>
#include <vtkm/cont/TryExecute.h>
typedef vtkm::Vec< vtkm::Float32, 3 > FloatVec3;
typedef vtkm::Vec< vtkm::UInt8, 4 > Uint8Vec4;
struct GenerateSurfaceWorklet : public vtkm::worklet::WorkletMapField
{
@ -55,77 +59,34 @@ struct GenerateSurfaceWorklet : public vtkm::worklet::WorkletMapField
}
};
template<bool> struct CanRun;
template<typename T, typename DeviceAdapterTag>
void run_if_valid(vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > inHandle,
vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > outCoords,
vtkm::cont::ArrayHandle< vtkm::Vec< vtkm::UInt8, 4 > > outColors,
DeviceAdapterTag tag)
struct RunGenerateSurfaceWorklet
{
typedef vtkm::cont::DeviceAdapterTraits<DeviceAdapterTag>
DeviceAdapterTraits;
if(DeviceAdapterTraits::Valid)
{
std::cout << "Running a worklet on device adapter: "
<< DeviceAdapterTraits::GetName() << std::endl;
}
else
{
std::cout << "Unable to run a worklet on device adapter: "
<< DeviceAdapterTraits::GetName() << std::endl;
}
CanRun<DeviceAdapterTraits::Valid>::run(inHandle,outCoords,outColors,tag);
}
//Implementation that we call on device adapters we don't have support
//enabled for
template<>
struct CanRun<false>
{
template<typename T, typename DeviceAdapterTag>
static void run(vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > vtkmNotUsed(inHandle),
vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > vtkmNotUsed(outCoords),
vtkm::cont::ArrayHandle< vtkm::Vec< vtkm::UInt8, 4 > > vtkmNotUsed(outColors),
DeviceAdapterTag)
template<typename DeviceAdapterTag>
bool operator()(DeviceAdapterTag ) const
{
}
};
//At this point we know we have runtime support
typedef vtkm::cont::DeviceAdapterTraits<DeviceAdapterTag> DeviceTraits;
//Implementation that we call on device adapters we do have support
//enabled for
template<>
struct CanRun<true>
{
template<typename T, typename DeviceAdapterTag>
static void run(vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > inHandle,
vtkm::cont::ArrayHandle< vtkm::Vec< T, 3 > > outCoords,
vtkm::cont::ArrayHandle< vtkm::Vec< vtkm::UInt8, 4 > > outColors,
DeviceAdapterTag)
{
//even though we have support for this device adapter we haven't determined
//if we actually have run-time support. This is a significant issue with
//the CUDA backend
vtkm::cont::RuntimeDeviceInformation<DeviceAdapterTag> runtime;
const bool haveSupport = runtime.Exists();
if(haveSupport)
{
typedef vtkm::worklet::DispatcherMapField<GenerateSurfaceWorklet,
DeviceAdapterTag> DispatcherType;
GenerateSurfaceWorklet worklet( 0.05f );
DispatcherType(worklet).Invoke( inHandle,
outCoords,
outColors);
}
std::cout << "Running a worklet on device adapter: "
<< DeviceTraits::GetName() << std::endl;
GenerateSurfaceWorklet worklet( 0.05f );
DispatcherType(worklet).Invoke( this->In,
this->Out,
this->Color);
return true;
}
vtkm::cont::ArrayHandle< FloatVec3 > In;
vtkm::cont::ArrayHandle< FloatVec3 > Out;
vtkm::cont::ArrayHandle< Uint8Vec4 > Color;
};
template<typename T>
std::vector< vtkm::Vec<T, 3> > make_testData(int size)
{
@ -143,27 +104,39 @@ std::vector< vtkm::Vec<T, 3> > make_testData(int size)
return data;
}
//This is the list of devices to compile in support for. The order of the
//devices determines the runtime preference.
struct DevicesToTry
: vtkm::ListTagBase<
vtkm::cont::DeviceAdapterTagCuda,
vtkm::cont::DeviceAdapterTagTBB,
vtkm::cont::DeviceAdapterTagSerial> { };
int main(int, char**)
{
typedef vtkm::Vec< vtkm::Float32, 3 > FloatVec3;
typedef vtkm::Vec< vtkm::UInt8, 4 > Uint8Vec4;
std::vector< FloatVec3 > data = make_testData<vtkm::Float32>(1024);
typedef ::vtkm::cont::DeviceAdapterTagSerial SerialTag;
typedef ::vtkm::cont::DeviceAdapterTagTBB TBBTag;
typedef ::vtkm::cont::DeviceAdapterTagCuda CudaTag;
//make array handles for the data
vtkm::cont::ArrayHandle< FloatVec3 > in = vtkm::cont::make_ArrayHandle(data);
vtkm::cont::ArrayHandle< FloatVec3 > out;
vtkm::cont::ArrayHandle< Uint8Vec4 > color;
//Run the algorithm on all backends that we have compiled support for.
run_if_valid(in, out, color, CudaTag());
run_if_valid(in, out, color, TBBTag());
run_if_valid(in, out, color, SerialTag());
// TryExecutes takes a functor and a list of devices. It then tries to run
// the functor for each device (in the order given in the list) until the
// execution succeeds. This allows you to compile in support for multiple
// devices which have runtime requirements ( GPU / HW Accelerator ) and
// correctly choose the best device at runtime.
//
// The functor parentheses operator should take exactly one argument, which is
// the DeviceAdapterTag to use. The functor should return true if the execution
// succeeds.
//
// This function also optionally takes a vtkm::cont::RuntimeDeviceTracker, which
// will monitor for certain failures across calls to TryExecute and skip trying
// devices with a history of failure.
RunGenerateSurfaceWorklet task;
task.In = vtkm::cont::make_ArrayHandle(data);
vtkm::cont::TryExecute(task, DevicesToTry());
}

30
examples/rendering/CMakeLists.txt
View File

@ -20,32 +20,16 @@
##
##=============================================================================
vtkm_configure_component_OpenGL()
vtkm_configure_component_Serial()
#vtkm_configure_component_CUDA()
#vtkm_configure_component_TBB()
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial OpenGL Rendering
)
if(VTKm_OpenGL_FOUND AND GLUT_FOUND)
find_package(GLUT)
if(VTKm_OpenGL_FOUND AND VTKm_Rendering_FOUND AND GLUT_FOUND)
add_executable(Rendering_SERIAL Rendering.cxx)
target_include_directories(Rendering_SERIAL PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
target_link_libraries(Rendering_SERIAL ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
target_compile_options(Rendering_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
# if(VTKm_CUDA_FOUND)
# vtkm_disable_troublesome_thrust_warnings()
# # Cuda compiles do not respect target_include_directories
# cuda_include_directories(${VTKm_INCLUDE_DIRS} ${GLUT_INCLUDE_DIRS})
# cuda_add_executable(Rendering_CUDA Rendering.cu)
# target_include_directories(Rendering_CUDA PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
# target_link_libraries(Rendering_CUDA ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
# target_compile_options(Rendering_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
# endif()
# if(VTKm_TBB_FOUND)
# add_executable(Rendering_TBB IsosurfaceUniformGridTBB.cxx)
# target_include_directories(Rendering_TBB PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
# target_link_libraries(Rendering_TBB ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
# target_compile_options(Rendering_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
# endif()
endif()

6
examples/rendering/Rendering.cxx
View File

@ -42,10 +42,10 @@
#include <vtkm/rendering/CanvasGL.h>
#include <vtkm/rendering/MapperGL.h>
#include <vtkm/rendering/View.h>
#include <vtkm/rendering/View3D.h>
#include <vtkm/rendering/ColorTable.h>
vtkm::rendering::View3D *view = NULL;
vtkm::rendering::View3D *view = nullptr;
const vtkm::Int32 W = 512, H = 512;
int buttonStates[3] = {GLUT_UP, GLUT_UP, GLUT_UP};
@ -138,7 +138,7 @@ main(int argc, char* argv[])
vtkm::rendering::Color bg(0.2f, 0.2f, 0.2f, 1.0f);
vtkm::rendering::CanvasGL canvas;
vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> mapper;
vtkm::rendering::MapperGL mapper;
vtkm::rendering::Scene scene;
scene.AddActor(vtkm::rendering::Actor(ds.GetCellSet(),

10
examples/streamline/CMakeLists.txt
View File

@ -20,12 +20,12 @@
##
##=============================================================================
find_package(GLUT)
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB OpenGL
)
vtkm_configure_component_OpenGL()
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
find_package(GLUT)
if(VTKm_OpenGL_FOUND AND GLUT_FOUND)
add_executable(StreamLineUniformGrid_SERIAL StreamLineUniformGrid.cxx)

6
examples/streamline/StreamLineUniformGrid.cxx
View File

@ -148,7 +148,7 @@ void displayCall()
vtkm::cont::CellSetExplicit<> cellSet;
outDataSet.GetCellSet(0).CopyTo(cellSet);
const vtkm::cont::DynamicArrayHandleCoordinateSystem &coordArray =
outDataSet.GetCoordinateSystem(0).GetData();
outDataSet.GetCoordinateSystem().GetData();
vtkm::Id numberOfCells = cellSet.GetNumberOfCells();
vtkm::Id numberOfPoints = coordArray.GetNumberOfValues();
@ -156,7 +156,7 @@ void displayCall()
// Need the actual vertex points from a static cast of the dynamic array but can't get it right
// So use cast and call on a functor that stores that dynamic array into static array we created
vertexArray.Allocate(numberOfPoints);
coordArray.CastAndCall(GetVertexArray());
vtkm::cont::CastAndCall(coordArray, GetVertexArray());
// Each cell is a polyline
glColor3f(1.0f, 0.0f, 0.0f);
@ -237,7 +237,7 @@ int main(int argc, char* argv[])
// Read in the vector data for testing
FILE * pFile = fopen(argv[1], "rb");
if (pFile == NULL) perror ("Error opening file");
if (pFile == nullptr) perror ("Error opening file");
size_t ret_code = 0;
// Size of the dataset

10
examples/tetrahedra/CMakeLists.txt
View File

@ -20,12 +20,14 @@
##
##=============================================================================
#Find the VTK-m package
find_package(VTKm REQUIRED QUIET
OPTIONAL_COMPONENTS Serial CUDA TBB OpenGL
)
find_package(GLUT)
vtkm_configure_component_OpenGL()
vtkm_configure_component_Serial()
vtkm_configure_component_CUDA()
vtkm_configure_component_TBB()
if(VTKm_OpenGL_FOUND AND GLUT_FOUND)
add_executable(TetrahedralizeExplicitGrid_SERIAL TetrahedralizeExplicitGrid.cxx)

6
examples/tetrahedra/TetrahedralizeExplicitGrid.cxx
View File

@ -204,14 +204,10 @@ void displayCall()
outDataSet.GetCellSet(0).CopyTo(cellSet);
vtkm::Id numberOfCells = cellSet.GetNumberOfCells();
// Get the coordinate system and coordinate data
const vtkm::cont::DynamicArrayHandleCoordinateSystem coordArray =
outDataSet.GetCoordinateSystem(0).GetData();
// Need the actual vertex points from a static cast of the dynamic array but can't get it right
// So use cast and call on a functor that stores that dynamic array into static array we created
vertexArray.Allocate(numberOfInPoints);
coordArray.CastAndCall(GetVertexArray());
vtkm::cont::CastAndCall(outDataSet.GetCoordinateSystem(), GetVertexArray());
// Draw the five tetrahedra belonging to each hexadron
vtkm::Float32 color[5][3] = {

4
examples/tetrahedra/TetrahedralizeUniformGrid.cxx
View File

@ -170,13 +170,11 @@ void displayCall()
// Get the cell set, coordinate system and coordinate data
vtkm::cont::CellSetSingleType<> cellSet;
tetDataSet.GetCellSet(0).CopyTo(cellSet);
const vtkm::cont::DynamicArrayHandleCoordinateSystem &coordArray =
tetDataSet.GetCoordinateSystem(0).GetData();
// Need the actual vertex points from a static cast of the dynamic array but can't get it right
// So use cast and call on a functor that stores that dynamic array into static array we created
vertexArray.Allocate(numberOfInPoints);
coordArray.CastAndCall(GetVertexArray());
vtkm::cont::CastAndCall(tetDataSet.GetCoordinateSystem(), GetVertexArray());
// Draw the five tetrahedra belonging to each hexadron
vtkm::Id tetra = 0;

6
examples/tetrahedra/TriangulateExplicitGrid.cxx
View File

@ -176,14 +176,10 @@ void displayCall()
outDataSet.GetCellSet(0).CopyTo(cellSet);
vtkm::Id numberOfCells = cellSet.GetNumberOfCells();
// Get the coordinate system and coordinate data
const vtkm::cont::DynamicArrayHandleCoordinateSystem coordArray =
outDataSet.GetCoordinateSystem(0).GetData();
// Need the actual vertex points from a static cast of the dynamic array but can't get it right
// So use cast and call on a functor that stores that dynamic array into static array we created
vertexArray.Allocate(numberOfInPoints);
coordArray.CastAndCall(GetVertexArray());
vtkm::cont::CastAndCall(outDataSet.GetCoordinateSystem(), GetVertexArray());
// Draw the two triangles belonging to each quad
vtkm::Float32 color[4][3] = {

4
examples/tetrahedra/TriangulateUniformGrid.cxx
View File

@ -132,13 +132,11 @@ void displayCall()
// Get the cellset, coordinate system and coordinate data
vtkm::cont::CellSetSingleType<> cellSet;
tetDataSet.GetCellSet(0).CopyTo(cellSet);
const vtkm::cont::DynamicArrayHandleCoordinateSystem &coordArray =
tetDataSet.GetCoordinateSystem(0).GetData();
// Need the actual vertex points from a static cast of the dynamic array but can't get it right
// So use cast and call on a functor that stores that dynamic array into static array we created
vertexArray.Allocate(numberOfInPoints);
coordArray.CastAndCall(GetVertexArray());
vtkm::cont::CastAndCall(tetDataSet.GetCoordinateSystem(), GetVertexArray());
// Draw the two triangles belonging to each quad
vtkm::Id triangle = 0;

2
vtkm/CMakeLists.txt
View File

@ -18,8 +18,6 @@
## this software.
##============================================================================
include_directories(${Boost_INCLUDE_DIRS})
set(headers
Assert.h
BinaryPredicates.h

14
vtkm/CellShape.h
View File

@ -23,10 +23,6 @@
#include <vtkm/StaticAssert.h>
#include <vtkm/Types.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/integral_constant.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
/// CellShapeId identifies the type of each cell. Currently these are designed
@ -63,10 +59,10 @@ enum CellShapeIdEnum
namespace internal {
/// A class that can be used to determine if a class is a CellShapeTag or not.
/// The class will be either boost::true_type or boost::false_type.
/// The class will be either std::true_type or std::false_type.
///
template<typename T>
struct CellShapeTagCheck : boost::false_type { };
struct CellShapeTagCheck : std::false_type { };
} // namespace internal
@ -87,7 +83,7 @@ struct CellShapeIdToTag {
// probably means you are using an ID that does not have a defined cell
// shape.
typedef boost::false_type valid;
typedef std::false_type valid;
};
@ -100,7 +96,7 @@ struct CellShapeIdToTag {
}; \
namespace internal { \
template<> \
struct CellShapeTagCheck<vtkm::CellShapeTag ## name> : boost::true_type { }; \
struct CellShapeTagCheck<vtkm::CellShapeTag ## name> : std::true_type { }; \
} \
VTKM_EXEC_CONT_EXPORT \
const char *GetCellShapeName(vtkm::CellShapeTag ## name) { \
@ -108,7 +104,7 @@ struct CellShapeIdToTag {
} \
template<> \
struct CellShapeIdToTag<vtkm::idname> { \
typedef boost::true_type valid; \
typedef std::true_type valid; \
typedef vtkm::CellShapeTag ## name Tag; \
}

8
vtkm/ListTag.h
View File

@ -25,9 +25,7 @@
#include <vtkm/StaticAssert.h>
#include <vtkm/internal/ExportMacros.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <type_traits>
namespace vtkm {
@ -36,8 +34,8 @@ namespace internal {
template<typename ListTag>
struct ListTagCheck
{
static const bool Valid =
boost::is_base_of<vtkm::detail::ListRoot,ListTag>::value;
static VTKM_CONSTEXPR bool Valid = std::is_base_of<vtkm::detail::ListRoot,
ListTag>::value;
};
} // namespace internal

604
vtkm/Math.h
View File

File diff suppressed because it is too large Load Diff

237
vtkm/Math.h.in
View File

@ -32,7 +32,7 @@ $# expander.py Math.h.in > Math.h
$#
$# Ignore the following comment. It is meant for the generated file.
// **** DO NOT EDIT THIS FILE!!! ****
// This file is automatically generated by FunctionInterfaceDetailPre.h.in
// This file is automatically generated by Math.h.in
#ifndef vtk_m_Math_h
#define vtk_m_Math_h
@ -45,52 +45,32 @@ $# Ignore the following comment. It is meant for the generated file.
#include <limits.h>
#include <math.h>
#include <stdlib.h>
// The nonfinite and sign test functions are usually defined as macros, and
// boost seems to want to undefine those macros so that it can implement the
// C99 templates and other implementations of the same name. Get around the
// problem by using the boost version when compiling for a CPU.
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/math/special_functions/sign.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <cmath>
#define VTKM_USE_BOOST_CLASSIFY
#define VTKM_USE_BOOST_SIGN
#endif // !VTKM_CUDA
#if !defined(__CUDA_ARCH__)
#define VTKM_USE_STL_MIN_MAX
#define VTKM_USE_STL
#include <algorithm>
#endif
#if defined(VTKM_MSVC) && !defined(VTKM_CUDA)
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/math/special_functions/acosh.hpp>
#include <boost/math/special_functions/asinh.hpp>
#include <boost/math/special_functions/atanh.hpp>
#include <boost/math/special_functions/cbrt.hpp>
#include <boost/math/special_functions/expm1.hpp>
#include <boost/math/special_functions/log1p.hpp>
#include <boost/math/special_functions/round.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#define VTKM_USE_BOOST_MATH
#if (_MSC_VER <= 1600) && !defined(VTKM_USE_STL_MIN_MAX)
#define VTKM_USE_STL_MIN_MAX
#include <algorithm>
#endif
#include <math.h>
#endif
#define VTKM_SYS_MATH_FUNCTION_32(func) func ## f
#define VTKM_SYS_MATH_FUNCTION_64(func) func
#define VTKM_CUDA_MATH_FUNCTION_32(func) func ## f
#define VTKM_CUDA_MATH_FUNCTION_64(func) func
$py(
def unary_function(name, type, returntype, expression):
def unary_function(name, type, returntype, cuda_expression, std_expression):
return '''VTKM_EXEC_CONT_EXPORT
{2} {0}({1} x) {{
#ifdef VTKM_CUDA
return {3};
#else
return {4};
#endif
}}
'''.format(name, type, returntype, expression)
'''.format(name, type, returntype, cuda_expression, std_expression)
def unary_Vec_function(vtkmname):
return '''template<typename T, vtkm::IdComponent N>
@ -130,11 +110,13 @@ def unary_math_function_no_vec(vtkmname, sysname, returntype = None):
return unary_function(vtkmname,
'vtkm::Float32',
'vtkm::Float32' if returntype == None else returntype,
'VTKM_SYS_MATH_FUNCTION_32(' + sysname + ')(x)') + \
'VTKM_CUDA_MATH_FUNCTION_32(' + sysname + ')(x)',
'std::' + sysname + '(x)') + \
unary_function(vtkmname,
'vtkm::Float64',
'vtkm::Float64' if returntype == None else returntype,
'VTKM_SYS_MATH_FUNCTION_64(' + sysname + ')(x)')
'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(x)',
'std::' + sysname + '(x)')
def unary_math_function(vtkmname, sysname):
return unary_math_function_no_vec(vtkmname, sysname) + \
@ -161,20 +143,26 @@ def unary_template_function_no_vec(vtkmname,
'vtkm::Float64' if returntype == None else returntype,
preexpression)
def binary_function(name, type, expression):
def binary_function(name, type, cuda_expression, std_expression):
return '''VTKM_EXEC_CONT_EXPORT
{1} {0}({1} x, {1} y) {{
#ifdef VTKM_CUDA
return {2};
#else
return {3};
#endif
}}
'''.format(name, type, expression)
'''.format(name, type, cuda_expression, std_expression)
def binary_math_function(vtkmname, sysname):
return binary_function(vtkmname,
'vtkm::Float32',
'VTKM_SYS_MATH_FUNCTION_32(' + sysname + ')(x,y)') + \
'VTKM_CUDA_MATH_FUNCTION_32(' + sysname + ')(x,y)',
'std::' + sysname + '(x,y)') + \
binary_function(vtkmname,
'vtkm::Float64',
'VTKM_SYS_MATH_FUNCTION_64(' + sysname + ')(x,y)')
'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(x,y)',
'std::' + sysname + '(x,y)')
def binary_template_function(vtkmname, expression):
return '''VTKM_EXEC_CONT_EXPORT
@ -279,35 +267,20 @@ $unary_math_function('TanH', 'tanh')\
/// Compute the hyperbolic arc sine of \p x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('ASinH', 'boost::math::asinh(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('ASinH', 'asinh')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('ASinH')\
/// Compute the hyperbolic arc cosine of \p x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('ACosH', 'boost::math::acosh(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('ACosH', 'acosh')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('ACosH')\
/// Compute the hyperbolic arc tangent of \p x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('ATanH', 'boost::math::atanh(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('ATanH', 'atanh')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('ATanH')\
//-----------------------------------------------------------------------------
@ -325,23 +298,31 @@ $unary_math_function('Sqrt', 'sqrt')\
/// should use this function whenever dividing by the square root.
///
#ifdef VTKM_CUDA
$unary_math_function_no_vec('RSqrt', 'rsqrt')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 RSqrt(vtkm::Float32 x) {
return rsqrtf(x);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 RSqrt(vtkm::Float64 x) {
return rsqrt(x);
}
#else // !VTKM_CUDA
$unary_template_function_no_vec('RSqrt', '1/vtkm::Sqrt(x)')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 RSqrt(vtkm::Float32 x) {
return 1/vtkm::Sqrt(x);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 RSqrt(vtkm::Float64 x) {
return 1/vtkm::Sqrt(x);
}
#endif // !VTKM_CUDA
$unary_Vec_function('RSqrt')\
/// Compute the cube root of \p x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('Cbrt', 'boost::math::cbrt(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('Cbrt', 'cbrt')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('Cbrt')\
/// Compute the reciprocal cube root of \p x. The result of this function is
@ -350,12 +331,25 @@ $unary_Vec_function('Cbrt')\
/// should use this function whenever dividing by the cube root.
///
#ifdef VTKM_CUDA
$unary_math_function_no_vec('RCbrt', 'rcbrt')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 RCbrt(vtkm::Float32 x) {
return rcbrtf(x);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 RCbrt(vtkm::Float64 x) {
return rcbrt(x);
}
#else // !VTKM_CUDA
$unary_template_function_no_vec('RCbrt', '1/vtkm::Cbrt(x)')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 RCbrt(vtkm::Float32 x) {
return 1/vtkm::Cbrt(x);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 RCbrt(vtkm::Float64 x) {
return 1/vtkm::Cbrt(x);
}
#endif // !VTKM_CUDA
$unary_Vec_function('RCbrt')\
/// Computes e**\p x, the base-e exponential of \p x.
@ -364,36 +358,39 @@ $unary_math_function('Exp', 'exp')\
/// Computes 2**\p x, the base-2 exponential of \p x.
///
#ifdef VTKM_MSVC
$unary_template_function_no_vec('Exp2', 'vtkm::Pow(2,x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('Exp2', 'exp2')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('Exp2')\
/// Computes (e**\p x) - 1, the of base-e exponental of \p x then minus 1. The
/// accuracy of this function is good even for very small values of x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('ExpM1', 'boost::math::expm1(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('ExpM1', 'expm1')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('ExpM1')\
/// Computes 10**\p x, the base-10 exponential of \p x.
///
#ifdef VTKM_CUDA
$unary_math_function_no_vec('Exp10', 'exp10')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 Exp10(vtkm::Float32 x) {
return exp10f(x);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 Exp10(vtkm::Float64 x) {
return exp10(x);
}
#else // !VTKM_CUDA
$unary_template_function_no_vec('Exp10', 'vtkm::Pow(10, x);')\
$#
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 Exp10(vtkm::Float32 x) {
return vtkm::Pow(10, x);;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 Exp10(vtkm::Float64 x) {
return vtkm::Pow(10, x);;
}
#endif // !VTKM_CUDA
$unary_Vec_function('Exp10')\
/// Computes the natural logarithm of \p x.
@ -402,25 +399,8 @@ $unary_math_function('Log', 'log')\
/// Computes the logarithm base 2 of \p x.
///
#ifdef VTKM_MSVC
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 Log2(vtkm::Float32 x) {
//windows and boost don't provide log2
//0.6931471805599453 is the constant value of log(2)
const vtkm::Float32 log2v = 0.6931471805599453f;
return vtkm::Log(x)/log2v;
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 Log2(vtkm::Float64 x) {
//windows and boost don't provide log2
//0.6931471805599453 is the constant value of log(2)
const vtkm::Float64 log2v = 0.6931471805599453;
return vtkm::Log(x)/log2v;
}
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('Log2', 'log2')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('Log2')\
/// Computes the logarithm base 10 of \p x.
@ -429,13 +409,8 @@ $unary_math_function('Log10', 'log10')\
/// Computes the value of log(1+x) accurately for very small values of x.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('Log1P', 'boost::math::log1p(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('Log1P', 'log1p')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('Log1P')\
//-----------------------------------------------------------------------------
@ -444,26 +419,26 @@ $unary_Vec_function('Log1P')\
template<typename T>
VTKM_EXEC_CONT_EXPORT
T Max(const T &x, const T &y);
#ifdef VTKM_USE_STL_MIN_MAX
#ifdef VTKM_USE_STL
$binary_template_function('Max', '(std::max)(x, y)')\
$#
#else // !VTKM_USE_STL_MIN_MAX
#else // !VTKM_USE_STL
$binary_math_function('Max', 'fmax')\
$#
#endif // !VTKM_USE_STL_MIN_MAX
#endif // !VTKM_USE_STL
/// Returns \p x or \p y, whichever is smaller.
///
template<typename T>
VTKM_EXEC_CONT_EXPORT
T Min(const T &x, const T &y);
#ifdef VTKM_USE_STL_MIN_MAX
#ifdef VTKM_USE_STL
$binary_template_function('Min', '(std::min)(x, y)')\
$#
#else // !VTKM_USE_STL_MIN_MAX
#else // !VTKM_USE_STL
$binary_math_function('Min', 'fmin')\
$#
#endif // !VTKM_USE_STL_MIN_MAX
#endif // !VTKM_USE_STL
namespace detail {
@ -754,9 +729,7 @@ template<typename T>
VTKM_EXEC_CONT_EXPORT
bool IsNan(T x)
{
#ifdef VTKM_USE_BOOST_CLASSIFY
using boost::math::isnan;
#endif
using std::isnan;
return (isnan(x) != 0);
}
@ -766,9 +739,7 @@ template<typename T>
VTKM_EXEC_CONT_EXPORT
bool IsInf(T x)
{
#ifdef VTKM_USE_BOOST_CLASSIFY
using boost::math::isinf;
#endif
using std::isinf;
return (isinf(x) != 0);
}
@ -778,9 +749,7 @@ template<typename T>
VTKM_EXEC_CONT_EXPORT
bool IsFinite(T x)
{
#ifdef VTKM_USE_BOOST_CLASSIFY
using boost::math::isfinite;
#endif
using std::isfinite;
return (isfinite(x) != 0);
}
@ -795,13 +764,8 @@ $unary_math_function('Floor', 'floor')\
/// Round \p x to the nearest integral value.
///
#ifdef VTKM_USE_BOOST_MATH
$unary_template_function_no_vec('Round', 'boost::math::round(x)')\
$#
#else // !VTKM_USE_BOOST_MATH
$unary_math_function_no_vec('Round', 'round')\
$#
#endif // !VTKM_USE_BOOST_MATH
$unary_Vec_function('Round')\
//-----------------------------------------------------------------------------
@ -841,16 +805,10 @@ vtkm::Float32 RemainderQuotient(vtkm::Float32 numerator,
vtkm::Float32 denominator,
QType &quotient)
{
#ifdef VTKM_USE_BOOST_MATH
quotient = static_cast<QType>(boost::math::round(numerator/denominator));
return vtkm::Remainder(numerator, denominator);
#else
int iQuotient;
vtkm::Float32 result =
VTKM_SYS_MATH_FUNCTION_32(remquo)(numerator, denominator, &iQuotient);
vtkm::Float32 result = std::remquo(numerator, denominator, &iQuotient);
quotient = iQuotient;
return result;
#endif
}
template<typename QType>
VTKM_EXEC_CONT_EXPORT
@ -858,16 +816,10 @@ vtkm::Float64 RemainderQuotient(vtkm::Float64 numerator,
vtkm::Float64 denominator,
QType &quotient)
{
#ifdef VTKM_USE_BOOST_MATH
quotient = static_cast<QType>(boost::math::round(numerator/denominator));
return vtkm::Remainder(numerator, denominator);
#else
int iQuotient;
vtkm::Float64 result =
VTKM_SYS_MATH_FUNCTION_64(remquo)(numerator, denominator, &iQuotient);
vtkm::Float64 result = std::remquo(numerator, denominator, &iQuotient);
quotient = iQuotient;
return result;
#endif
}
/// Gets the integral and fractional parts of \c x. The return value is the
@ -876,12 +828,12 @@ vtkm::Float64 RemainderQuotient(vtkm::Float64 numerator,
VTKM_EXEC_CONT_EXPORT
vtkm::Float32 ModF(vtkm::Float32 x, vtkm::Float32 &integral)
{
return VTKM_SYS_MATH_FUNCTION_32(modf)(x, &integral);
return std::modf(x, &integral);
}
VTKM_EXEC_CONT_EXPORT
vtkm::Float64 ModF(vtkm::Float64 x, vtkm::Float64 &integral)
{
return VTKM_SYS_MATH_FUNCTION_64(modf)(x, &integral);
return std::modf(x, &integral);
}
//-----------------------------------------------------------------------------
@ -915,9 +867,8 @@ $unary_math_function('Abs', 'fabs')\
$unary_template_function_no_vec('SignBit',
'static_cast<vtkm::Int32>(signbit(x))',
'vtkm::Int32',
'''#ifdef VTKM_USE_BOOST_SIGN
using boost::math::signbit;
#endif
'''
using std::signbit;
''')\
/// Returns true if \p x is less than zero, false otherwise.
@ -927,13 +878,9 @@ $unary_template_function_no_vec('IsNegative', '(vtkm::SignBit(x) != 0)', 'bool')
/// Copies the sign of \p y onto \p x. If \p y is positive, returns Abs(\p x).
/// If \p y is negative, returns -Abs(\p x).
///
#ifdef VTKM_USE_BOOST_SIGN
$binary_template_function('CopySign', 'boost::math::copysign(x,y)')\
$#
#else // !VTKM_USE_BOOST_SIGN
$binary_math_function('CopySign', 'copysign')\
$#
#endif // !VTKM_USE_BOOST_SIGN
template<typename T, vtkm::IdComponent N>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<T,N> CopySign(const vtkm::Vec<T,N> &x, const vtkm::Vec<T,N> &y)

28
vtkm/StaticAssert.h
View File

@ -21,34 +21,12 @@
#define vtk_m_StaticAssert_h
#include <vtkm/internal/Configure.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/static_assert.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
// Newer versions of clang are causing the static assert to issue a warning
// about unused typedefs. In this case, we want to disable the warnings using
// pragmas. However, not all compiler support pragmas in code blocks (although
// fortunately clang does). Thus, only use these pragmas in the instance where
// we need it and know we can use it.
#if defined(VTKM_CLANG) && (__apple_build_version__ >= 7000072) && !defined(VTKM_CUDA)
#include <type_traits>
#define VTKM_STATIC_ASSERT(condition) \
VTKM_THIRDPARTY_PRE_INCLUDE \
BOOST_STATIC_ASSERT(condition) \
VTKM_THIRDPARTY_POST_INCLUDE
static_assert( (condition), __FILE__)
#define VTKM_STATIC_ASSERT_MSG(condition, message) \
VTKM_THIRDPARTY_PRE_INCLUDE \
BOOST_STATIC_ASSERT_MSG(condition, message) \
VTKM_THIRDPARTY_POST_INCLUDE
static_assert( (condition), message)
#else
#define VTKM_STATIC_ASSERT(condition) \
BOOST_STATIC_ASSERT(condition)
#define VTKM_STATIC_ASSERT_MSG(condition, message) \
BOOST_STATIC_ASSERT_MSG(condition, message)
#endif
#endif //vtk_m_StaticAssert_h

31
vtkm/TopologyElementTag.h
View File

@ -22,10 +22,6 @@
#include <vtkm/Types.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/mpl/assert.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
/// \brief A tag used to identify the cell elements in a topology.
@ -63,44 +59,41 @@ struct TopologyElementTagFace { };
namespace internal {
/// Checks to see if the given object is a topology element tag. This check is
/// compatible with the Boost meta-template programing library (MPL). It
/// contains a typedef named \c type that is either boost::mpl::true_ or
/// boost::mpl::false_. Both of these have a typedef named value with the
/// Checks to see if the given object is a topology element tag.This check is
/// compatible with C++11 type_traits.
/// It contains a typedef named \c type that is either std::true_type or
/// std::false_type. Both of these have a typedef named value with the
/// respective boolean value.
///
template<typename T>
struct TopologyElementTagCheck
struct TopologyElementTagCheck : std::false_type
{
typedef boost::mpl::false_ type;
};
template<>
struct TopologyElementTagCheck<vtkm::TopologyElementTagCell>
struct TopologyElementTagCheck<vtkm::TopologyElementTagCell> : std::true_type
{
typedef boost::mpl::true_ type;
};
template<>
struct TopologyElementTagCheck<vtkm::TopologyElementTagPoint>
struct TopologyElementTagCheck<vtkm::TopologyElementTagPoint> : std::true_type
{
typedef boost::mpl::true_ type;
};
template<>
struct TopologyElementTagCheck<vtkm::TopologyElementTagEdge>
struct TopologyElementTagCheck<vtkm::TopologyElementTagEdge> : std::true_type
{
typedef boost::mpl::true_ type;
};
template<>
struct TopologyElementTagCheck<vtkm::TopologyElementTagFace>
struct TopologyElementTagCheck<vtkm::TopologyElementTagFace> : std::true_type
{
typedef boost::mpl::true_ type;
};
#define VTKM_IS_TOPOLOGY_ELEMENT_TAG(type) \
BOOST_MPL_ASSERT(( ::vtkm::internal::TopologyElementTagCheck<type> ))
static_assert( ::vtkm::internal::TopologyElementTagCheck<type>::value, \
"Invalid Topology Element Tag being used");
} // namespace internal

25
vtkm/Transform3D.h
View File

@ -53,11 +53,34 @@ vtkm::Vec<T,3> Transform3DPoint(const vtkm::Matrix<T,4,4> &matrix,
vtkm::dot(vtkm::MatrixGetRow(matrix,2), homogeneousPoint));
}
/// \brief Transform a 3D point by a transformation matrix.
/// \brief Transform a 3D point by a transformation matrix with perspective.
///
/// Given a 4x4 transformation matrix and a 3D point, returns the point
/// transformed by the given matrix in homogeneous coordinates.
///
/// Unlike Transform3DPoint, this method honors the fourth component of the
/// transformed homogeneous coordiante. This makes it applicable for perspective
/// transformations, but requires some more computations.
///
template<typename T>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<T,3> Transform3DPointPerspective(const vtkm::Matrix<T,4,4> &matrix,
const vtkm::Vec<T,3> &point)
{
vtkm::Vec<T,4> homogeneousPoint(point[0], point[1], point[2], T(1));
T inverseW = 1/vtkm::dot(vtkm::MatrixGetRow(matrix,3), homogeneousPoint);
return vtkm::Vec<T,3>(
vtkm::dot(vtkm::MatrixGetRow(matrix,0), homogeneousPoint)*inverseW,
vtkm::dot(vtkm::MatrixGetRow(matrix,1), homogeneousPoint)*inverseW,
vtkm::dot(vtkm::MatrixGetRow(matrix,2), homogeneousPoint)*inverseW);
}
/// \brief Transform a 3D vector by a transformation matrix.
///
/// Given a 4x4 transformation matrix and a 3D vector, returns the vector
/// transformed by the given matrix in homogeneous coordinates. Unlike points,
/// vectors do not get translated.
///
template<typename T>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<T,3> Transform3DVector(const vtkm::Matrix<T,4,4> &matrix,

51
vtkm/Types.h
View File

@ -20,20 +20,13 @@
#ifndef vtk_m_Types_h
#define vtk_m_Types_h
#include <vtkm/internal/Configure.h>
#include <vtkm/internal/ExportMacros.h>
#include <vtkm/Assert.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/mpl/or.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/type_traits/is_signed.hpp>
#include <boost/utility/enable_if.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <iostream>
#include <type_traits>
/*!
* \namespace vtkm
@ -1237,18 +1230,48 @@ operator*(const vtkm::Vec<vtkm::Float64, Size> &vec, vtkm::Float64 scalar)
vtkm::Float64,vtkm::internal::Multiply>(scalar));
}
template<typename T, vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<T, Size> operator/(const vtkm::Vec<T, Size> &vec, T scalar)
{
return vtkm::internal::VecComponentWiseUnaryOperation<Size>()(
vec,
vtkm::internal::BindRightBinaryOp<T,vtkm::internal::Divide>(scalar));
}
template<typename T, vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<T, Size>
operator/(const vtkm::Vec<T, Size> &vec, vtkm::Float64 scalar)
{
return vtkm::Vec<T, Size>(
vtkm::internal::VecComponentWiseUnaryOperation<Size>()(
vec,
vtkm::internal::BindRightBinaryOp<
vtkm::Float64,vtkm::internal::Divide,T>(scalar)));
}
template<vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
vtkm::Vec<vtkm::Float64, Size>
operator/(const vtkm::Vec<vtkm::Float64, Size> &vec, vtkm::Float64 scalar)
{
return vtkm::internal::VecComponentWiseUnaryOperation<Size>()(
vec,
vtkm::internal::BindRightBinaryOp<
vtkm::Float64,vtkm::internal::Divide>(scalar));
}
// The enable_if for this operator is effectively disabling the negate
// operator for Vec of unsigned integers. Another approach would be
// to use disable_if<is_unsigned>. That would be more inclusive but would
// to use enable_if<!is_unsigned>. That would be more inclusive but would
// also allow other types like Vec<Vec<unsigned> >. If necessary, we could
// change this implementation to be more inclusive.
template<typename T, vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
typename boost::enable_if<
typename boost::mpl::or_<
typename boost::is_floating_point<T>::type,
typename boost::is_signed<T>::type>::type,
vtkm::Vec<T,Size> >::type
typename std::enable_if<
(std::is_floating_point<T>::value || std::is_signed<T>::value),
vtkm::Vec<T,Size>
>::type
operator-(const vtkm::Vec<T,Size> &x)
{
return vtkm::internal::VecComponentWiseUnaryOperation<Size>()(

8
vtkm/VecTraits.h
View File

@ -22,10 +22,6 @@
#include <vtkm/Types.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/remove_const.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
/// A tag for vectors that are "true" vectors (i.e. have more than one
@ -103,10 +99,10 @@ struct VecTraits
/// Returns the value in a given component of the vector.
///
VTKM_EXEC_CONT_EXPORT static const ComponentType &GetComponent(
const typename boost::remove_const<VecType>::type &vector,
const typename std::remove_const<VecType>::type &vector,
vtkm::IdComponent component);
VTKM_EXEC_CONT_EXPORT static ComponentType &GetComponent(
typename boost::remove_const<VecType>::type &vector,
typename std::remove_const<VecType>::type &vector,
vtkm::IdComponent component);
/// Changes the value in a given component of the vector.

15
vtkm/benchmarking/BenchmarkDeviceAdapter.cxx
View File

@ -33,17 +33,12 @@
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/benchmarking/Benchmarker.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/random.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <algorithm>
#include <cctype>
#include <cmath>
#include <ctime>
#include <iostream>
#include <utility>
#include <random>
#include <string>
#include <utility>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
@ -167,7 +162,7 @@ private:
ValueArrayHandle ValueHandle_src;
ValueArrayHandle ValueHandle_dst;
boost::mt19937 Rng;
std::mt19937 Rng;
VTKM_CONT_EXPORT
BenchCopy(){
@ -362,7 +357,7 @@ private:
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle ValueHandle;
boost::mt19937 Rng;
std::mt19937 Rng;
VTKM_CONT_EXPORT
BenchSort(){
@ -392,7 +387,7 @@ private:
struct BenchSortByKey {
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
boost::mt19937 Rng;
std::mt19937 Rng;
vtkm::Id N_KEYS;
ValueArrayHandle ValueHandle;
IdArrayHandle KeyHandle;

575
vtkm/benchmarking/BenchmarkFieldAlgorithms.cxx Normal file
View File

@ -0,0 +1,575 @@
//============================================================================
// 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 <vtkm/Math.h>
#include <vtkm/VectorAnalysis.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/WorkletMapTopology.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/DispatcherMapTopology.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/benchmarking/Benchmarker.h>
#include <random>
#include <string>
namespace vtkm {
namespace benchmarking {
#define ARRAY_SIZE (1 << 22)
#define CUBE_SIZE 256
const static std::string DIVIDER(40, '-');
enum BenchmarkName {
BLACK_SCHOLES = 1,
MATH = 1 << 1,
FUSED_MATH = 1 << 3,
INTERPOLATE_FIELD = 1 << 4,
ALL = BLACK_SCHOLES |
MATH |
FUSED_MATH |
INTERPOLATE_FIELD
};
template<typename T>
class BlackScholes : public vtkm::worklet::WorkletMapField
{
T Riskfree;
T Volatility;
public:
typedef void ControlSignature(FieldIn<Scalar>, FieldIn<Scalar>,
FieldIn<Scalar>, FieldOut<Scalar>,
FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2,_3,_4,_5);
BlackScholes(T risk, T volatility):
Riskfree(risk),
Volatility(volatility)
{
}
VTKM_EXEC_EXPORT
T CumulativeNormalDistribution(T d) const
{
const vtkm::Float32 A1 = 0.31938153f;
const vtkm::Float32 A2 = -0.356563782f;
const vtkm::Float32 A3 = 1.781477937f;
const vtkm::Float32 A4 = -1.821255978f;
const vtkm::Float32 A5 = 1.330274429f;
const vtkm::Float32 RSQRT2PI = 0.39894228040143267793994605993438f;
const T K = T(1.0f) / ( T(1.0f) + T(0.2316419f) * vtkm::Abs(d));
T cnd = RSQRT2PI * vtkm::Exp(-0.5f * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
if(d > 0)
{
cnd = 1.0f - cnd;
}
return cnd;
}
VTKM_EXEC_EXPORT
void operator()(const T& stockPrice, const T& optionStrike, const T& optionYears,
T& callResult, T& putResult) const
{
// Black-Scholes formula for both call and put
const T sqrtYears = vtkm::Sqrt(optionYears);
const T volMultSqY = this->Volatility * sqrtYears;
const T d1 = ( vtkm::Log(stockPrice / optionStrike) + (this->Riskfree + 0.5f * Volatility * Volatility) * optionYears) / (volMultSqY);
const T d2 = d1 - volMultSqY;
const T CNDD1 = CumulativeNormalDistribution(d1);
const T CNDD2 = CumulativeNormalDistribution(d2);
//Calculate Call and Put simultaneously
T expRT = vtkm::Exp( - this->Riskfree * optionYears);
callResult = stockPrice * CNDD1 - optionStrike * expRT * CNDD2;
putResult = optionStrike * expRT * (1.0f - CNDD2) - stockPrice * (1.0f - CNDD1);
}
};
class Mag : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2);
template<typename T>
VTKM_EXEC_EXPORT
void operator()(const vtkm::Vec<T,3>& vec, T& result) const
{
result = vtkm::Magnitude(vec);
}
};
class Square : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2);
template<typename T>
VTKM_EXEC_EXPORT
void operator()(T input, T& output) const
{
output = input * input;
}
};
class Sin : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2);
template<typename T>
VTKM_EXEC_EXPORT
void operator()(T input, T& output) const
{
output = vtkm::Sin(input);
}
};
class Cos : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2);
template<typename T>
VTKM_EXEC_EXPORT
void operator()(T input, T& output) const
{
output = vtkm::Cos(input);
}
};
class FusedMath : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
typedef void ExecutionSignature(_1,_2);
template<typename T>
VTKM_EXEC_EXPORT
void operator()(const vtkm::Vec<T,3>& vec, T& result) const
{
const T m = vtkm::Magnitude(vec);
result = vtkm::Cos( vtkm::Sin(m) * vtkm::Sin(m) );
}
};
class GenerateEdges : public vtkm::worklet::WorkletMapPointToCell
{
public:
typedef void ControlSignature( CellSetIn cellset, WholeArrayOut< > edgeIds);
typedef void ExecutionSignature(PointIndices, ThreadIndices, _2);
typedef _1 InputDomain;
template<typename ConnectivityInVec,
typename ThreadIndicesType,
typename IdPairTableType>
VTKM_EXEC_EXPORT
void operator()(const ConnectivityInVec &connectivity,
const ThreadIndicesType threadIndices,
const IdPairTableType &edgeIds) const
{
const vtkm::Id writeOffset = (threadIndices.GetInputIndex() * 12);
const vtkm::IdComponent edgeTable[24] = { 0, 1, 1, 2, 3, 2, 0, 3,
4, 5, 5, 6, 7, 6, 4, 7,
0, 4, 1, 5, 2, 6, 3, 7 };
for(vtkm::Id i=0; i < 12; ++i)
{
const vtkm::Id offset = (i*2);
const vtkm::Id2 edge( connectivity[ edgeTable[offset] ],
connectivity[ edgeTable[offset+1] ] );
edgeIds.Set(writeOffset+i, edge);
}
}
};
class InterpolateField : public vtkm::worklet::WorkletMapField
{
public:
typedef void ControlSignature(FieldIn< Id2Type > interpolation_ids,
FieldIn< Scalar > interpolation_weights,
WholeArrayIn<> inputField,
FieldOut<> output
);
typedef void ExecutionSignature(_1, _2, _3, _4);
typedef _1 InputDomain;
template <typename WeightType, typename InFieldPortalType, typename OutFieldType>
VTKM_EXEC_EXPORT
void operator()(const vtkm::Id2& low_high,
const WeightType &weight,
const InFieldPortalType& inPortal,
OutFieldType &result) const
{
//fetch the low / high values from inPortal
result = vtkm::Lerp(inPortal.Get(low_high[0]),
inPortal.Get(low_high[1]),
weight);
}
};
/// This class runs a series of micro-benchmarks to measure
/// performance of different field operations
template<class DeviceAdapterTag>
class BenchmarkFieldAlgorithms {
typedef vtkm::cont::StorageTagBasic StorageTag;
typedef vtkm::cont::ArrayHandle<vtkm::Id, StorageTag> IdArrayHandle;
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag> Algorithm;
typedef vtkm::cont::Timer<DeviceAdapterTag> Timer;
private:
template<typename Value>
struct BenchBlackScholes {
typedef vtkm::cont::ArrayHandle<Value, StorageTag> ValueArrayHandle;
ValueArrayHandle StockPrice;
ValueArrayHandle OptionStrike;
ValueArrayHandle OptionYears;
std::vector<Value> price;
std::vector<Value> strike;
std::vector<Value> years;
VTKM_CONT_EXPORT
BenchBlackScholes()
{
std::mt19937 rng;
std::uniform_real_distribution<Value> price_range(Value(5.0f),Value(30.0f));
std::uniform_real_distribution<Value> strike_range(Value(1.0f),Value(100.0f));
std::uniform_real_distribution<Value> year_range(Value(0.25f),Value(10.0f));
this->price.resize(ARRAY_SIZE);
this->strike.resize(ARRAY_SIZE);
this->years.resize(ARRAY_SIZE);
for(std::size_t i=0; i < ARRAY_SIZE; ++i )
{
this->price[i] = price_range(rng);
this->strike[i] = strike_range(rng);
this->years[i] = year_range(rng);
}
this->StockPrice = vtkm::cont::make_ArrayHandle(this->price);
this->OptionStrike = vtkm::cont::make_ArrayHandle(this->strike);
this->OptionYears = vtkm::cont::make_ArrayHandle(this->years);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::ArrayHandle<Value> callResultHandle, putResultHandle;
const Value RISKFREE = 0.02f;
const Value VOLATILITY = 0.30f;
Timer timer;
BlackScholes<Value> worklet(RISKFREE, VOLATILITY);
vtkm::worklet::DispatcherMapField< BlackScholes<Value> > dispatcher(worklet);
dispatcher.Invoke( this->StockPrice,
this->OptionStrike,
this->OptionYears,
callResultHandle,
putResultHandle
);
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
std::stringstream description;
description << "BlackScholes " << ARRAY_SIZE << " stocks";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(BlackScholes, BenchBlackScholes);
template<typename Value>
struct BenchMath {
std::vector< vtkm::Vec<Value, 3> > input;
vtkm::cont::ArrayHandle< vtkm::Vec<Value, 3>, StorageTag> InputHandle;
VTKM_CONT_EXPORT
BenchMath()
{
std::mt19937 rng;
std::uniform_real_distribution<Value> range;
this->input.resize(ARRAY_SIZE);
for(std::size_t i=0; i < ARRAY_SIZE; ++i )
{
this->input[i] = vtkm::Vec<Value, 3>(range(rng),
range(rng),
range(rng));
}
this->InputHandle = vtkm::cont::make_ArrayHandle(this->input);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::ArrayHandle<Value> tempHandle1;
vtkm::cont::ArrayHandle<Value> tempHandle2;
Timer timer;
vtkm::worklet::DispatcherMapField< Mag >().Invoke( InputHandle, tempHandle1 );
vtkm::worklet::DispatcherMapField< Sin >().Invoke( tempHandle1, tempHandle2 );
vtkm::worklet::DispatcherMapField< Square >().Invoke( tempHandle2, tempHandle1 );
vtkm::worklet::DispatcherMapField< Cos >().Invoke( tempHandle1, tempHandle2 );
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
std::stringstream description;
description << "Magnitude -> Sine -> Square -> Cosine " << ARRAY_SIZE << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(Math, BenchMath);
template<typename Value>
struct BenchFusedMath {
std::vector< vtkm::Vec<Value, 3> > input;
vtkm::cont::ArrayHandle< vtkm::Vec<Value, 3>, StorageTag> InputHandle;
VTKM_CONT_EXPORT
BenchFusedMath()
{
std::mt19937 rng;
std::uniform_real_distribution<Value> range;
this->input.resize(ARRAY_SIZE);
for(std::size_t i=0; i < ARRAY_SIZE; ++i )
{
this->input[i] = vtkm::Vec<Value, 3>(range(rng),
range(rng),
range(rng));
}
this->InputHandle = vtkm::cont::make_ArrayHandle(this->input);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::ArrayHandle<Value> result;
Timer timer;
vtkm::worklet::DispatcherMapField< FusedMath >().Invoke( this->InputHandle, result );
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
std::stringstream description;
description << "Fused Magnitude -> Sine -> Square -> Cosine " << ARRAY_SIZE << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(FusedMath, BenchFusedMath);
template<typename Value>
struct BenchEdgeInterp {
std::vector<vtkm::Float32> weight;
std::vector<Value> field;
vtkm::cont::ArrayHandle< vtkm::Float32, StorageTag> WeightHandle;
vtkm::cont::ArrayHandle< Value, StorageTag> FieldHandle;
vtkm::cont::ArrayHandle< vtkm::Id2, StorageTag> EdgePairHandle;
VTKM_CONT_EXPORT
BenchEdgeInterp()
{
std::mt19937 rng;
std::uniform_real_distribution<vtkm::Float32> weight_range(0.0f,1.0f);
std::uniform_real_distribution<Value> field_range;
//basically the core challenge is to generate an array whose
//indexing pattern matches that of a edge based algorithm.
//
//So for this kind of problem we generate the 12 edges of each
//cell and place them into array.
//
vtkm::cont::CellSetStructured<3> cellSet;
cellSet.SetPointDimensions( vtkm::Id3(CUBE_SIZE,CUBE_SIZE,CUBE_SIZE) );
const vtkm::Id numberOfEdges = cellSet.GetNumberOfCells() * 12;
const std::size_t esize = static_cast<std::size_t>(numberOfEdges);
const std::size_t psize = static_cast<std::size_t>(cellSet.GetNumberOfPoints());
this->EdgePairHandle.Allocate( numberOfEdges );
vtkm::worklet::DispatcherMapTopology< GenerateEdges >().Invoke( cellSet,
this->EdgePairHandle );
this->weight.resize( esize );
for(std::size_t i=0; i < esize; ++i )
{
this->weight[i] = weight_range(rng);
}
this->field.resize( psize );
for(std::size_t i=0; i < psize; ++i )
{
this->field[i] = field_range(rng);
}
this->FieldHandle = vtkm::cont::make_ArrayHandle(this->field);
this->WeightHandle = vtkm::cont::make_ArrayHandle(this->weight);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::ArrayHandle<Value> result;
Timer timer;
vtkm::worklet::DispatcherMapField<
InterpolateField,
DeviceAdapterTag>().Invoke(this->EdgePairHandle,
this->WeightHandle,
this->FieldHandle,
result);
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
std::stringstream description;
const std::size_t size = (CUBE_SIZE-1)*(CUBE_SIZE-1)*(CUBE_SIZE-1)*12;
description << "Edge Interpolation of an array of " << size << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(EdgeInterp, BenchEdgeInterp);
public:
struct ValueTypes : vtkm::ListTagBase<vtkm::Float32, vtkm::Float64>{};
struct InterpValueTypes : vtkm::ListTagBase<vtkm::Float32,
vtkm::Float64,
vtkm::Vec< vtkm::Float32, 3>,
vtkm::Vec< vtkm::Float64, 3>
>{};
static VTKM_CONT_EXPORT int Run(int benchmarks){
std::cout << DIVIDER << "\nRunning Field Algorithm benchmarks\n";
if (benchmarks & BLACK_SCHOLES) {
std::cout << DIVIDER << "\nBenchmarking BlackScholes\n";
VTKM_RUN_BENCHMARK(BlackScholes, ValueTypes());
}
if (benchmarks & MATH){
std::cout << DIVIDER << "\nBenchmarking Multiple Math Worklets\n";
VTKM_RUN_BENCHMARK(Math, ValueTypes());
}
if (benchmarks & FUSED_MATH){
std::cout << DIVIDER << "\nBenchmarking Single Fused Math Worklet\n";
VTKM_RUN_BENCHMARK(FusedMath, ValueTypes());
}
if (benchmarks & INTERPOLATE_FIELD){
std::cout << DIVIDER << "\nBenchmarking Edge Based Field InterpolationWorklet\n";
VTKM_RUN_BENCHMARK(EdgeInterp, ValueTypes());
}
return 0;
}
};
#undef ARRAY_SIZE
}
} // namespace vtkm::benchmarking
int main(int argc, char *argv[])
{
int benchmarks = 0;
if (argc < 2){
benchmarks = vtkm::benchmarking::ALL;
}
else {
for (int i = 1; i < argc; ++i){
std::string arg = argv[i];
std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
if (arg == "blackscholes")
{
benchmarks |= vtkm::benchmarking::BLACK_SCHOLES;
}
else if (arg == "math")
{
benchmarks |= vtkm::benchmarking::MATH;
}
else if (arg == "fusedmath")
{
benchmarks |= vtkm::benchmarking::FUSED_MATH;
}
else if (arg == "interpolate")
{
benchmarks |= vtkm::benchmarking::INTERPOLATE_FIELD;
}
else
{
std::cout << "Unrecognized benchmark: " << argv[i] << std::endl;
return 1;
}
}
}
//now actually execute the benchmarks
return vtkm::benchmarking::BenchmarkFieldAlgorithms
<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Run(benchmarks);
}

399
vtkm/benchmarking/BenchmarkTopologyAlgorithms.cxx Normal file
View File

@ -0,0 +1,399 @@
//============================================================================
// 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 <vtkm/Math.h>
#include <vtkm/VectorAnalysis.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/worklet/WorkletMapTopology.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/DispatcherMapTopology.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/benchmarking/Benchmarker.h>
#include <random>
#include <string>
namespace vtkm {
namespace benchmarking {
#define CUBE_SIZE 256
const static std::string DIVIDER(40, '-');
enum BenchmarkName {
CELL_TO_POINT = 1 << 1,
POINT_TO_CELL = 1 << 2,
MC_CLASSIFY = 1 << 3,
ALL = CELL_TO_POINT |
POINT_TO_CELL |
MC_CLASSIFY
};
class AveragePointToCell : public vtkm::worklet::WorkletMapPointToCell
{
public:
typedef void ControlSignature(FieldInPoint<> inPoints,
CellSetIn cellset,
FieldOutCell<> outCells);
typedef void ExecutionSignature(_1, PointCount, _3);
typedef _2 InputDomain;
template<typename PointValueVecType, typename OutType>
VTKM_EXEC_EXPORT
void operator()(const PointValueVecType &pointValues,
const vtkm::IdComponent &numPoints,
OutType &average) const
{
OutType sum = static_cast<OutType>(pointValues[0]);
for (vtkm::IdComponent pointIndex = 1; pointIndex < numPoints; ++pointIndex)
{
sum = sum + static_cast<OutType>(pointValues[pointIndex]);
}
average = sum / static_cast<OutType>(numPoints);
}
};
class AverageCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
{
public:
typedef void ControlSignature(FieldInCell<> inCells,
CellSetIn topology,
FieldOut<> outPoints);
typedef void ExecutionSignature(_1, _3, CellCount);
typedef _2 InputDomain;
template<typename CellVecType, typename OutType>
VTKM_EXEC_EXPORT
void operator()(const CellVecType &cellValues,
OutType &avgVal,
const vtkm::IdComponent &numCellIDs) const
{
//simple functor that returns the average cell Value.
avgVal = static_cast<OutType>(cellValues[0]);
for (vtkm::IdComponent cellIndex = 1; cellIndex < numCellIDs; ++cellIndex)
{
avgVal += static_cast<OutType>(cellValues[cellIndex]);
}
avgVal = avgVal / static_cast<OutType>(numCellIDs);
}
};
// -----------------------------------------------------------------------------
template<typename T>
class Classification : public vtkm::worklet::WorkletMapPointToCell
{
public:
typedef void ControlSignature(
FieldInPoint<> inNodes,
CellSetIn cellset,
FieldOutCell< IdComponentType > outCaseId);
typedef void ExecutionSignature(_1, _3);
typedef _2 InputDomain;
T IsoValue;
VTKM_CONT_EXPORT
Classification(T isovalue) :
IsoValue(isovalue)
{
}
template<typename FieldInType>
VTKM_EXEC_EXPORT
void operator()(const FieldInType &fieldIn,
vtkm::IdComponent &caseNumber) const
{
typedef typename vtkm::VecTraits<FieldInType>::ComponentType FieldType;
const FieldType iso = static_cast<FieldType>(this->IsoValue);
caseNumber= ((fieldIn[0] > iso) |
(fieldIn[1] > iso) << 1 |
(fieldIn[2] > iso) << 2 |
(fieldIn[3] > iso) << 3 |
(fieldIn[4] > iso) << 4 |
(fieldIn[5] > iso) << 5 |
(fieldIn[6] > iso) << 6 |
(fieldIn[7] > iso) << 7);
}
};
/// This class runs a series of micro-benchmarks to measure
/// performance of different field operations
template<class DeviceAdapterTag>
class BenchmarkTopologyAlgorithms {
typedef vtkm::cont::StorageTagBasic StorageTag;
typedef vtkm::cont::ArrayHandle<vtkm::Id, StorageTag> IdArrayHandle;
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag> Algorithm;
typedef vtkm::cont::Timer<DeviceAdapterTag> Timer;
private:
template<typename T, typename Enable= void> struct NumberGenerator {};
template<typename T>
struct NumberGenerator<T,
typename std::enable_if<
std::is_floating_point<T>::value
>::type
>
{
std::mt19937 rng;
std::uniform_real_distribution<T> distribution;
NumberGenerator(T low, T high): rng(), distribution(low,high) {}
T next() { return distribution(rng); }
};
template<typename T>
struct NumberGenerator<T,
typename std::enable_if<
!std::is_floating_point<T>::value
>::type
>
{
std::mt19937 rng;
std::uniform_int_distribution<T> distribution;
NumberGenerator(T low, T high): rng(), distribution(low,high) {}
T next() { return distribution(rng); }
};
template<typename Value>
struct BenchCellToPointAvg {
std::vector< Value > input;
vtkm::cont::ArrayHandle< Value, StorageTag> InputHandle;
VTKM_CONT_EXPORT
BenchCellToPointAvg()
{
NumberGenerator<Value> generator(static_cast<Value>(1.0),
static_cast<Value>(100.0));
//cube size is points in each dim
const std::size_t csize = (CUBE_SIZE-1)*(CUBE_SIZE-1)*(CUBE_SIZE-1);
this->input.resize( csize );
for(std::size_t i=0; i < csize; ++i )
{
this->input[i] = generator.next();
}
this->InputHandle = vtkm::cont::make_ArrayHandle(this->input);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::CellSetStructured<3> cellSet;
cellSet.SetPointDimensions( vtkm::Id3(CUBE_SIZE,CUBE_SIZE,CUBE_SIZE) );
vtkm::cont::ArrayHandle<Value,StorageTag> result;
Timer timer;
vtkm::worklet::DispatcherMapTopology< AverageCellToPoint > dispatcher;
dispatcher.Invoke( this->InputHandle,
cellSet,
result);
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
const std::size_t csize = (CUBE_SIZE-1)*(CUBE_SIZE-1)*(CUBE_SIZE-1);
std::stringstream description;
description << "Computing Cell To Point Average for cell " << csize << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(CellToPointAvg, BenchCellToPointAvg);
template<typename Value>
struct BenchPointToCellAvg {
std::vector< Value > input;
vtkm::cont::ArrayHandle< Value, StorageTag> InputHandle;
VTKM_CONT_EXPORT
BenchPointToCellAvg()
{
NumberGenerator<Value> generator(static_cast<Value>(1.0),
static_cast<Value>(100.0));
const std::size_t psize = (CUBE_SIZE)*(CUBE_SIZE)*(CUBE_SIZE);
this->input.resize( psize );
for(std::size_t i=0; i < psize; ++i )
{
this->input[i] = generator.next();
}
this->InputHandle = vtkm::cont::make_ArrayHandle(this->input);
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::CellSetStructured<3> cellSet;
cellSet.SetPointDimensions( vtkm::Id3(CUBE_SIZE,CUBE_SIZE,CUBE_SIZE) );
vtkm::cont::ArrayHandle<Value,StorageTag> result;
Timer timer;
vtkm::worklet::DispatcherMapTopology< AveragePointToCell > dispatcher;
dispatcher.Invoke( this->InputHandle,
cellSet,
result);
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
const std::size_t psize = (CUBE_SIZE)*(CUBE_SIZE)*(CUBE_SIZE);
std::stringstream description;
description << "Computing Point To Cell Average for point " << psize << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(PointToCellAvg, BenchPointToCellAvg);
template<typename Value>
struct BenchClassification {
std::vector< Value > input;
vtkm::cont::ArrayHandle< Value, StorageTag> InputHandle;
Value IsoValue;
VTKM_CONT_EXPORT
BenchClassification()
{
NumberGenerator<Value> generator(static_cast<Value>(1.0),
static_cast<Value>(100.0));
const std::size_t psize = (CUBE_SIZE)*(CUBE_SIZE)*(CUBE_SIZE);
this->input.resize( psize );
for(std::size_t i=0; i < psize; ++i )
{
this->input[i] = generator.next();
}
this->InputHandle = vtkm::cont::make_ArrayHandle(this->input);
this->IsoValue = generator.next();
}
VTKM_CONT_EXPORT
vtkm::Float64 operator()()
{
vtkm::cont::CellSetStructured<3> cellSet;
cellSet.SetPointDimensions( vtkm::Id3(CUBE_SIZE,CUBE_SIZE,CUBE_SIZE) );
vtkm::cont::ArrayHandle< vtkm::IdComponent, StorageTag> result;
Timer timer;
Classification<Value> worklet(this->IsoValue);
vtkm::worklet::DispatcherMapTopology< Classification<Value> > dispatcher(worklet);
dispatcher.Invoke( this->InputHandle,
cellSet,
result);
return timer.GetElapsedTime();
}
VTKM_CONT_EXPORT
std::string Description() const {
const std::size_t psize = (CUBE_SIZE)*(CUBE_SIZE)*(CUBE_SIZE);
std::stringstream description;
description << "Computing Marching Cubes Classification for point " << psize << " values";
return description.str();
}
};
VTKM_MAKE_BENCHMARK(Classification, BenchClassification);
public:
struct ValueTypes : vtkm::ListTagBase<vtkm::UInt32, vtkm::Int32, vtkm::Int64,
vtkm::Float32, vtkm::Float64 >{};
static VTKM_CONT_EXPORT int Run(int benchmarks){
std::cout << DIVIDER << "\nRunning Topology Algorithm benchmarks\n";
if (benchmarks & CELL_TO_POINT) {
std::cout << DIVIDER << "\nBenchmarking Cell To Point Average\n";
VTKM_RUN_BENCHMARK(CellToPointAvg, ValueTypes());
}
if (benchmarks & POINT_TO_CELL){
std::cout << DIVIDER << "\nBenchmarking Point to Cell Average\n";
VTKM_RUN_BENCHMARK(PointToCellAvg, ValueTypes());
}
if (benchmarks & MC_CLASSIFY){
std::cout << DIVIDER << "\nBenchmarking Hex/Voxel MC Classification\n";
VTKM_RUN_BENCHMARK(Classification, ValueTypes());
}
return 0;
}
};
#undef ARRAY_SIZE
}
} // namespace vtkm::benchmarking
int main(int argc, char *argv[])
{
int benchmarks = 0;
if (argc < 2){
benchmarks = vtkm::benchmarking::ALL;
}
else {
for (int i = 1; i < argc; ++i){
std::string arg = argv[i];
std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
if (arg == "celltopoint")
{
benchmarks |= vtkm::benchmarking::CELL_TO_POINT;
}
else if (arg == "pointtocell")
{
benchmarks |= vtkm::benchmarking::POINT_TO_CELL;
}
else if (arg == "classify")
{
benchmarks |= vtkm::benchmarking::MC_CLASSIFY;
}
else {
std::cout << "Unrecognized benchmark: " << argv[i] << std::endl;
return 1;
}
}
}
//now actually execute the benchmarks
return vtkm::benchmarking::BenchmarkTopologyAlgorithms
<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>::Run(benchmarks);
}

2
vtkm/benchmarking/CMakeLists.txt
View File

@ -20,6 +20,8 @@
set(benchmark_srcs
BenchmarkDeviceAdapter.cxx
BenchmarkFieldAlgorithms.cxx
BenchmarkTopologyAlgorithms.cxx
)
set(benchmark_headers

113
vtkm/cont/ArrayHandle.h
View File

@ -32,15 +32,10 @@
#include <vtkm/cont/internal/ArrayHandleExecutionManager.h>
#include <vtkm/cont/internal/DeviceAdapterTag.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/concept_check.hpp>
#include <boost/mpl/not.hpp>
#include <boost/smart_ptr/scoped_ptr.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <memory>
#include <vector>
#include <iterator>
namespace vtkm {
namespace cont {
@ -56,48 +51,48 @@ namespace internal {
class ArrayHandleBase { };
/// Checks to see if the given type and storage can form a valid array handle
/// (some storage objects cannot support all types). This check is compatable
/// with the Boost meta-template programming library (MPL). It contains a
/// typedef named type that is either boost::mpl::true_ or boost::mpl::false_.
/// (some storage objects cannot support all types). This check is compatible
/// with C++11 type_traits. It contains a
/// typedef named type that is either std::true_type or std::false_type.
/// Both of these have a typedef named value with the respective boolean value.
///
template<typename T, typename StorageTag>
struct IsValidArrayHandle {
typedef typename boost::mpl::not_<
typename boost::is_base_of<
vtkm::cont::internal::UndefinedStorage,
vtkm::cont::internal::Storage<T,StorageTag>
>::type
>::type type;
//need to add the not
using type = std::integral_constant<bool,
!( std::is_base_of<
vtkm::cont::internal::UndefinedStorage,
vtkm::cont::internal::Storage<T,StorageTag>
>::value)>;
};
/// Checks to see if the ArrayHandle for the given DeviceAdatper allows
/// writing, as some ArrayHandles (Implicit) don't support writing.
/// This check is compatable with the Boost meta-template programming
/// library (MPL). It contains a typedef named type that is either
// boost::mpl::true_ or boost::mpl::false_.
/// This check is compatible with the C++11 type_traits.
/// It contains a typedef named type that is either
/// std::true_type or std::false_type.
/// Both of these have a typedef named value with the respective boolean value.
///
template<typename ArrayHandle, typename DeviceAdapterTag>
struct IsWriteableArrayHandle {
private:
typedef typename ArrayHandle:: template ExecutionTypes<
DeviceAdapterTag > ExecutionTypes;
typedef typename ExecutionTypes::Portal::ValueType ValueType;
template<typename T>
using ExecutionTypes = typename ArrayHandle::template ExecutionTypes<T>;
using ValueType = typename ExecutionTypes<DeviceAdapterTag>::Portal::ValueType;
//All ArrayHandles that use ImplicitStorage as the final writable location
//will have a value type of void*, which is what we are trying to detect
typedef typename boost::remove_pointer<ValueType>::type RawValueType;
typedef boost::is_void<RawValueType> IsVoidType;
using RawValueType = typename std::remove_pointer<ValueType>::type;
using IsVoidType = std::is_void<RawValueType>;
public:
typedef typename boost::mpl::not_<IsVoidType>::type type;
using type = std::integral_constant<bool, !IsVoidType::value>;
};
/// Checks to see if the given object is an array handle. This check is
/// compatible with the Boost meta-template programming library (MPL). It
/// contains a typedef named \c type that is either boost::mpl::true_ or
/// boost::mpl::false_. Both of these have a typedef named value with the
/// respective boolean value.
/// compatible with C++11 type_traits. It a typedef named \c type that is
/// either std::true_type or std::false_type. Both of these have a typedef
/// named value with the respective boolean value.
///
/// Unlike \c IsValidArrayHandle, if an \c ArrayHandle is used with this
/// class, then it must be created by the compiler and therefore must already
@ -109,8 +104,8 @@ public:
template<typename T>
struct ArrayHandleCheck
{
typedef typename boost::is_base_of<
::vtkm::cont::internal::ArrayHandleBase, T>::type type;
using type = typename std::is_base_of<
::vtkm::cont::internal::ArrayHandleBase, T>::type;
};
#define VTKM_IS_ARRAY_HANDLE(T) \
@ -232,10 +227,10 @@ template<
class ArrayHandle : public internal::ArrayHandleBase
{
private:
typedef vtkm::cont::internal::Storage<T,StorageTag_> StorageType;
typedef vtkm::cont::internal::ArrayHandleExecutionManagerBase<T,StorageTag_>
ExecutionManagerType;
public:
typedef vtkm::cont::internal::Storage<T,StorageTag_> StorageType;
typedef T ValueType;
typedef StorageTag_ StorageTag;
typedef typename StorageType::PortalType PortalControl;
@ -289,7 +284,6 @@ public:
/// with CUDA), then the automatically generated destructor could be
/// created for all devices, and it would not be valid for all devices.
///
VTKM_CONT_EXPORT
virtual ~ArrayHandle() { }
/// \brief Copies an ArrayHandle
@ -302,6 +296,38 @@ public:
return *this;
}
/// Get the storage.
///
VTKM_CONT_EXPORT StorageType& GetStorage()
{
this->SyncControlArray();
if (this->Internals->ControlArrayValid)
{
return this->Internals->ControlArray;
}
else
{
throw vtkm::cont::ErrorControlInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
/// Get the storage.
///
VTKM_CONT_EXPORT const StorageType& GetStorage() const
{
this->SyncControlArray();
if (this->Internals->ControlArrayValid)
{
return this->Internals->ControlArray;
}
else
{
throw vtkm::cont::ErrorControlInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
/// Get the array portal of the control array.
///
VTKM_CONT_EXPORT PortalControl GetPortalControl()
@ -359,11 +385,14 @@ public:
/// Copies data into the given iterator for the control environment. This
/// method can skip copying into an internally managed control array.
///
template <class IteratorType, class DeviceAdapterTag>
template<typename IteratorType, typename DeviceAdapterTag>
VTKM_CONT_EXPORT void CopyInto(IteratorType dest, DeviceAdapterTag) const
{
BOOST_CONCEPT_ASSERT((boost::OutputIterator<IteratorType, ValueType>));
BOOST_CONCEPT_ASSERT((boost::ForwardIterator<IteratorType>));
using pointer_type = typename std::iterator_traits<IteratorType>::pointer;
using value_type = typename std::remove_pointer<pointer_type>::type;
static_assert( !std::is_const<value_type>::value,
"CopyInto requires a non const iterator." );
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
@ -597,14 +626,14 @@ public:
StorageType ControlArray;
bool ControlArrayValid;
boost::scoped_ptr<
std::unique_ptr<
vtkm::cont::internal::ArrayHandleExecutionManagerBase<
ValueType,StorageTag> > ExecutionArray;
bool ExecutionArrayValid;
};
VTKM_CONT_EXPORT
ArrayHandle(const boost::shared_ptr<InternalStruct>& i)
ArrayHandle(const std::shared_ptr<InternalStruct>& i)
: Internals(i)
{ }
@ -617,7 +646,7 @@ public:
VTKM_CONT_EXPORT
void PrepareForDevice(DeviceAdapterTag) const
{
if (this->Internals->ExecutionArray != NULL)
if (this->Internals->ExecutionArray != nullptr)
{
if (this->Internals->ExecutionArray->IsDeviceAdapter(DeviceAdapterTag()))
{
@ -642,7 +671,7 @@ public:
}
}
VTKM_ASSERT(this->Internals->ExecutionArray == NULL);
VTKM_ASSERT(this->Internals->ExecutionArray == nullptr);
VTKM_ASSERT(!this->Internals->ExecutionArrayValid);
// Need to change some state that does not change the logical state from
// an external point of view.
@ -693,7 +722,7 @@ public:
}
}
boost::shared_ptr<InternalStruct> Internals;
std::shared_ptr<InternalStruct> Internals;
};
/// A convenience function for creating an ArrayHandle from a standard C array.

12
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -26,6 +26,7 @@
#include <vtkm/cont/ErrorControlBadAllocation.h>
namespace vtkm {
namespace exec {
namespace internal {
/// \brief An array portal that acts as a 3D cartesian product of 3 arrays.
@ -140,7 +141,8 @@ private:
};
}
} // namespace vtkm::internal
}
} // namespace vtkm::exec::internal
namespace vtkm {
@ -180,11 +182,11 @@ class Storage<T, StorageTagCartesianProduct<FirstHandleType, SecondHandleType, T
public:
typedef T ValueType;
typedef vtkm::internal::ArrayPortalCartesianProduct< ValueType,
typedef vtkm::exec::internal::ArrayPortalCartesianProduct< ValueType,
typename FirstHandleType::PortalControl,
typename SecondHandleType::PortalControl,
typename ThirdHandleType::PortalControl> PortalType;
typedef vtkm::internal::ArrayPortalCartesianProduct< ValueType,
typedef vtkm::exec::internal::ArrayPortalCartesianProduct< ValueType,
typename FirstHandleType::PortalConstControl,
typename SecondHandleType::PortalConstControl,
typename ThirdHandleType::PortalConstControl>
@ -284,14 +286,14 @@ public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::internal::ArrayPortalCartesianProduct<
typedef vtkm::exec::internal::ArrayPortalCartesianProduct<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::Portal,
typename SecondHandleType::template ExecutionTypes<Device>::Portal,
typename ThirdHandleType::template ExecutionTypes<Device>::Portal
> PortalExecution;
typedef vtkm::internal::ArrayPortalCartesianProduct<
typedef vtkm::exec::internal::ArrayPortalCartesianProduct<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::PortalConst,
typename SecondHandleType::template ExecutionTypes<Device>::PortalConst,

326
vtkm/cont/ArrayHandleConcatenate.h Normal file
View File

@ -0,0 +1,326 @@
//=============================================================================
//
// 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 2015 Sandia Corporation.
// Copyright 2015 UT-Battelle, LLC.
// Copyright 2015 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.
//
//=============================================================================
#ifndef vtk_m_ArrayHandleConcatenate_h
#define vtk_m_ArrayHandleConcatenate_h
#include <vtkm/cont/ArrayHandle.h>
namespace vtkm {
namespace cont {
namespace internal {
template< typename PortalType1, typename PortalType2 >
class ArrayPortalConcatenate
{
public:
typedef typename PortalType1::ValueType ValueType;
VTKM_EXEC_CONT_EXPORT
ArrayPortalConcatenate() : portal1(), portal2() {}
VTKM_EXEC_CONT_EXPORT
ArrayPortalConcatenate( const PortalType1 &p1, const PortalType2 &p2 )
: portal1( p1 ), portal2( p2 ) {}
// Copy constructor
template< typename OtherP1, typename OtherP2 >
VTKM_EXEC_CONT_EXPORT
ArrayPortalConcatenate( const ArrayPortalConcatenate< OtherP1, OtherP2 > &src )
: portal1( src.GetPortal1() ), portal2( src.GetPortal2() ) {}
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const
{
return this->portal1.GetNumberOfValues() +
this->portal2.GetNumberOfValues() ;
}
VTKM_EXEC_CONT_EXPORT
ValueType Get( vtkm::Id index) const
{
if( index < this->portal1.GetNumberOfValues() )
return this->portal1.Get( index );
else
return this->portal2.Get( index - this->portal1.GetNumberOfValues() );
}
VTKM_EXEC_CONT_EXPORT
void Set( vtkm::Id index, const ValueType &value ) const
{
if( index < this->portal1.GetNumberOfValues() )
this->portal1.Set( index, value );
else
this->portal2.Set( index - this->portal1.GetNumberOfValues(), value );
}
VTKM_EXEC_CONT_EXPORT
const PortalType1 &GetPortal1() const
{
return this->portal1;
}
VTKM_EXEC_CONT_EXPORT
const PortalType2 &GetPortal2() const
{
return this->portal2;
}
private:
PortalType1 portal1;
PortalType2 portal2;
}; // class ArrayPortalConcatenate
} // namespace internal
template< typename ArrayHandleType1, typename ArrayHandleType2 >
class StorageTagConcatenate {};
namespace internal {
template< typename ArrayHandleType1, typename ArrayHandleType2 >
class Storage< typename ArrayHandleType1::ValueType,
StorageTagConcatenate< ArrayHandleType1, ArrayHandleType2> >
{
public:
typedef typename ArrayHandleType1::ValueType ValueType;
typedef ArrayPortalConcatenate< typename ArrayHandleType1::PortalControl,
typename ArrayHandleType2::PortalControl > PortalType;
typedef ArrayPortalConcatenate<
typename ArrayHandleType1::PortalConstControl,
typename ArrayHandleType2::PortalConstControl > PortalConstType;
VTKM_CONT_EXPORT
Storage() : valid( false ) { }
VTKM_CONT_EXPORT
Storage( const ArrayHandleType1 &a1, const ArrayHandleType2 &a2 )
: array1( a1 ), array2( a2 ), valid( true ) {};
VTKM_CONT_EXPORT
PortalConstType GetPortalConst() const
{
VTKM_ASSERT( this->valid );
return PortalConstType( this->array1.GetPortalConstControl(),
this->array2.GetPortalConstControl() );
}
VTKM_CONT_EXPORT
PortalType GetPortal()
{
VTKM_ASSERT( this->valid );
return PortalType( this->array1.GetPortalControl(),
this->array2.GetPortalControl() );
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const
{
VTKM_ASSERT( this->valid );
return this->array1.GetNumberOfValues() + this->array2.GetNumberOfValues();
}
VTKM_CONT_EXPORT
void Allocate( vtkm::Id numberOfValues )
{
numberOfValues++; // dummy statement to avoid a warning
throw vtkm::cont::ErrorControlInternal(
"ArrayHandleConcatenate should not be allocated explicitly. " );
}
VTKM_CONT_EXPORT
void Shrink( vtkm::Id numberOfValues )
{
VTKM_ASSERT( this->valid );
if( numberOfValues < this->array1.GetNumberOfValues() )
{
this->array1.Shrink( numberOfValues );
this->array2.Shrink( 0 );
}
else
this->array2.Shrink( numberOfValues - this->array1.GetNumberOfValues() );
}
VTKM_CONT_EXPORT
void ReleaseResources( )
{
VTKM_ASSERT( this->valid );
this->array1.ReleaseResources();
this->array2.ReleaseResources();
}
VTKM_CONT_EXPORT
const ArrayHandleType1 &GetArray1() const
{
VTKM_ASSERT( this->valid );
return this->array1;
}
VTKM_CONT_EXPORT
const ArrayHandleType2 &GetArray2() const
{
VTKM_ASSERT( this->valid );
return this->array2;
}
private:
ArrayHandleType1 array1;
ArrayHandleType2 array2;
bool valid;
}; // class Storage
template< typename ArrayHandleType1, typename ArrayHandleType2, typename Device >
class ArrayTransfer< typename ArrayHandleType1::ValueType,
StorageTagConcatenate< ArrayHandleType1, ArrayHandleType2>,
Device >
{
public:
typedef typename ArrayHandleType1::ValueType ValueType;
private:
typedef StorageTagConcatenate< ArrayHandleType1, ArrayHandleType2 > StorageTag;
typedef vtkm::cont::internal::Storage< ValueType, StorageTag> StorageType;
public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef ArrayPortalConcatenate<
typename ArrayHandleType1::template ExecutionTypes< Device >::Portal,
typename ArrayHandleType2::template ExecutionTypes< Device >::Portal >
PortalExecution;
typedef ArrayPortalConcatenate<
typename ArrayHandleType1::template ExecutionTypes< Device >::PortalConst,
typename ArrayHandleType2::template ExecutionTypes< Device >::PortalConst >
PortalConstExecution;
VTKM_CONT_EXPORT
ArrayTransfer( StorageType* storage )
: array1( storage->GetArray1() ), array2( storage->GetArray2() ) {}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const
{
return this->array1.GetNumberOfValues() + this->array2.GetNumberOfValues() ;
}
VTKM_CONT_EXPORT
PortalConstExecution PrepareForInput( bool vtkmNotUsed( updateData ) )
{
return PortalConstExecution( this->array1.PrepareForInput( Device() ),
this->array2.PrepareForInput( Device() ));
}
VTKM_CONT_EXPORT
PortalExecution PrepareForInPlace( bool vtkmNotUsed( updateData ) )
{
return PortalExecution( this->array1.PrepareForInPlace( Device() ),
this->array2.PrepareForInPlace( Device() ));
}
VTKM_CONT_EXPORT
PortalExecution PrepareForOutput( vtkm::Id numberOfValues )
{
numberOfValues++; // dummy statement to avoid a warning
throw vtkm::cont::ErrorControlInternal(
"ArrayHandleConcatenate is derived and read-only. " );
}
VTKM_CONT_EXPORT
void RetrieveOutputData( StorageType* vtkmNotUsed(storage) ) const
{
// not need to implement
}
VTKM_CONT_EXPORT
void Shrink( vtkm::Id numberOfValues )
{
if( numberOfValues < this->array1.GetNumberOfValues() )
{
this->array1.Shrink( numberOfValues );
this->array2.Shrink( 0 );
}
else
this->array2.Shrink( numberOfValues - this->array1.GetNumberOfValues() );
}
VTKM_CONT_EXPORT
void ReleaseResources()
{
this->array1.ReleaseResourcesExecution();
this->array2.ReleaseResourcesExecution();
}
private:
ArrayHandleType1 array1;
ArrayHandleType2 array2;
};
}
}
} // namespace vtkm::cont::internal
namespace vtkm {
namespace cont {
template< typename ArrayHandleType1, typename ArrayHandleType2 >
class ArrayHandleConcatenate
: public vtkm::cont::ArrayHandle< typename ArrayHandleType1::ValueType,
StorageTagConcatenate< ArrayHandleType1, ArrayHandleType2> >
{
public:
VTKM_ARRAY_HANDLE_SUBCLASS( ArrayHandleConcatenate,
( ArrayHandleConcatenate< ArrayHandleType1, ArrayHandleType2> ),
( vtkm::cont::ArrayHandle< typename ArrayHandleType1::ValueType,
StorageTagConcatenate< ArrayHandleType1, ArrayHandleType2 > > ));
private:
typedef vtkm::cont::internal::Storage< ValueType, StorageTag > StorageType;
public:
VTKM_CONT_EXPORT
ArrayHandleConcatenate( const ArrayHandleType1 &array1,
const ArrayHandleType2 &array2 )
: Superclass( StorageType( array1, array2 ) )
{}
};
template< typename ArrayHandleType1, typename ArrayHandleType2 >
VTKM_CONT_EXPORT
ArrayHandleConcatenate< ArrayHandleType1, ArrayHandleType2 >
make_ArrayHandleConcatenate( const ArrayHandleType1 &array1,
const ArrayHandleType2 &array2 )
{
return ArrayHandleConcatenate< ArrayHandleType1, ArrayHandleType2 >( array1, array2 );
}
}
} // namespace vtkm::cont
#endif //vtk_m_ArrayHandleConcatenate_h

25
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -24,12 +24,8 @@
#include <vtkm/cont/ArrayPortal.h>
#include <vtkm/cont/ErrorControlBadValue.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/remove_const.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
namespace exec {
namespace internal {
@ -41,7 +37,7 @@ public:
typedef _SourcePortalType SourcePortalType;
typedef typename
boost::remove_const<typename SourcePortalType::ValueType>::type
std::remove_const<typename SourcePortalType::ValueType>::type
ComponentType;
typedef vtkm::Vec<ComponentType, NUM_COMPONENTS> ValueType;
@ -109,6 +105,15 @@ private:
SourcePortalType SourcePortal;
};
}
}
} // namespace vtkm::exec::internal
namespace vtkm {
namespace cont {
namespace internal {
template<typename SourceArrayHandleType, vtkm::IdComponent NUM_COMPONENTS>
struct StorageTagGroupVec { };
@ -124,10 +129,10 @@ class Storage<
public:
typedef vtkm::Vec<ComponentType,NUM_COMPONENTS> ValueType;
typedef vtkm::cont::internal::ArrayPortalGroupVec<
typedef vtkm::exec::internal::ArrayPortalGroupVec<
typename SourceArrayHandleType::PortalControl,
NUM_COMPONENTS> PortalType;
typedef vtkm::cont::internal::ArrayPortalGroupVec<
typedef vtkm::exec::internal::ArrayPortalGroupVec<
typename SourceArrayHandleType::PortalConstControl,
NUM_COMPONENTS> PortalConstType;
@ -223,11 +228,11 @@ public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::cont::internal::ArrayPortalGroupVec<
typedef vtkm::exec::internal::ArrayPortalGroupVec<
typename SourceArrayHandleType::template ExecutionTypes<Device>::Portal,
NUM_COMPONENTS>
PortalExecution;
typedef vtkm::cont::internal::ArrayPortalGroupVec<
typedef vtkm::exec::internal::ArrayPortalGroupVec<
typename SourceArrayHandleType::template ExecutionTypes<Device>::PortalConst,
NUM_COMPONENTS>
PortalConstExecution;

83
vtkm/cont/ArrayHandlePermutation.h
View File

@ -31,18 +31,19 @@ namespace exec {
namespace internal {
template<typename IndexPortalType, typename ValuePortalType>
class ArrayPortalPermutationExec
class ArrayPortalPermutation
{
public:
typedef typename ValuePortalType::ValueType ValueType;
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalPermutationExec( )
ArrayPortalPermutation( )
: IndexPortal(), ValuePortal() { }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalPermutationExec(
ArrayPortalPermutation(
const IndexPortalType &indexPortal,
const ValuePortalType &valuePortal)
: IndexPortal(indexPortal), ValuePortal(valuePortal) { }
@ -53,12 +54,14 @@ public:
/// const cast).
///
template<typename OtherIP, typename OtherVP>
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalPermutationExec(
const ArrayPortalPermutationExec<OtherIP,OtherVP> &src)
ArrayPortalPermutation(
const ArrayPortalPermutation<OtherIP,OtherVP> &src)
: IndexPortal(src.GetIndexPortal()), ValuePortal(src.GetValuePortal())
{ }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
return this->IndexPortal.GetNumberOfValues();
@ -78,9 +81,11 @@ public:
this->ValuePortal.Set(permutedIndex, value);
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
const IndexPortalType &GetIndexPortal() const { return this->IndexPortal; }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
const ValuePortalType &GetValuePortal() const { return this->ValuePortal; }
@ -98,66 +103,6 @@ namespace cont {
namespace internal {
template<typename IndexPortalType, typename ValuePortalType>
class ArrayPortalPermutationCont
{
public:
typedef typename ValuePortalType::ValueType ValueType;
VTKM_CONT_EXPORT
ArrayPortalPermutationCont( )
: IndexPortal(), ValuePortal() { }
VTKM_CONT_EXPORT
ArrayPortalPermutationCont(
const IndexPortalType &indexPortal,
const ValuePortalType &valuePortal)
: IndexPortal(indexPortal), ValuePortal(valuePortal) { }
/// Copy constructor for any other ArrayPortalPermutation with delegate
/// portal types that can be copied to these portal types. This allows us to
/// do any type casting that the delegate portals do (like the non-const to
/// const cast).
///
template<typename OtherIP, typename OtherVP>
VTKM_CONT_EXPORT
ArrayPortalPermutationCont(
const ArrayPortalPermutationCont<OtherIP,OtherVP> &src)
: IndexPortal(src.GetIndexPortal()), ValuePortal(src.GetValuePortal())
{ }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
return this->IndexPortal.GetNumberOfValues();
}
VTKM_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
vtkm::Id permutedIndex = this->IndexPortal.Get(index);
VTKM_ASSERT(permutedIndex >= 0);
VTKM_ASSERT(permutedIndex < this->ValuePortal.GetNumberOfValues());
return this->ValuePortal.Get(permutedIndex);
}
VTKM_CONT_EXPORT
ValueType Set(vtkm::Id index, const ValueType &value) const {
vtkm::Id permutedIndex = this->IndexPortal.Get(index);
VTKM_ASSERT(permutedIndex >= 0);
VTKM_ASSERT(permutedIndex < this->ValuePortal.GetNumberOfValues());
return this->ValuePortal.Set(permutedIndex, value);
}
VTKM_CONT_EXPORT
const IndexPortalType &GetIndexPortal() const { return this->IndexPortal; }
VTKM_CONT_EXPORT
const ValuePortalType &GetValuePortal() const { return this->ValuePortal; }
private:
IndexPortalType IndexPortal;
ValuePortalType ValuePortal;
};
template<typename IndexArrayType, typename ValueArrayType>
struct StorageTagPermutation { };
@ -172,10 +117,10 @@ class Storage<
public:
typedef typename ValueArrayType::ValueType ValueType;
typedef ArrayPortalPermutationCont<
typedef vtkm::exec::internal::ArrayPortalPermutation<
typename IndexArrayType::PortalConstControl,
typename ValueArrayType::PortalControl> PortalType;
typedef ArrayPortalPermutationCont<
typedef vtkm::exec::internal::ArrayPortalPermutation<
typename IndexArrayType::PortalConstControl,
typename ValueArrayType::PortalConstControl> PortalConstType;
@ -254,11 +199,11 @@ public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::exec::internal::ArrayPortalPermutationExec<
typedef vtkm::exec::internal::ArrayPortalPermutation<
typename IndexArrayType::template ExecutionTypes<Device>::PortalConst,
typename ValueArrayType::template ExecutionTypes<Device>::Portal>
PortalExecution;
typedef vtkm::exec::internal::ArrayPortalPermutationExec<
typedef vtkm::exec::internal::ArrayPortalPermutation<
typename IndexArrayType::template ExecutionTypes<Device>::PortalConst,
typename ValueArrayType::template ExecutionTypes<Device>::PortalConst>
PortalConstExecution;

134
vtkm/cont/ArrayHandleTransform.h
View File

@ -47,46 +47,52 @@ typedef vtkm::cont::internal::NullFunctorType NullFunctorType;
///
template<typename ValueType_, typename PortalType_, typename FunctorType_,
typename InverseFunctorType_=NullFunctorType>
class ArrayPortalExecTransform;
class ArrayPortalTransform;
template<typename ValueType_, typename PortalType_, typename FunctorType_>
class ArrayPortalExecTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
class ArrayPortalTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
{
public:
typedef PortalType_ PortalType;
typedef ValueType_ ValueType;
typedef FunctorType_ FunctorType;
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalExecTransform(const PortalType &portal = PortalType(),
ArrayPortalTransform(const PortalType &portal = PortalType(),
const FunctorType &functor = FunctorType())
: Portal(portal), Functor(functor)
{ }
/// Copy constructor for any other ArrayPortalExecTransform with an iterator
/// Copy constructor for any other ArrayPortalTransform with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherP, class OtherF>
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalExecTransform(const ArrayPortalExecTransform<OtherV,OtherP,OtherF> &src)
ArrayPortalTransform(const ArrayPortalTransform<OtherV,OtherP,OtherF> &src)
: Portal(src.GetPortal()),
Functor(src.GetFunctor())
{ }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
return this->Portal.GetNumberOfValues();
}
VTKM_EXEC_EXPORT
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return this->Functor(this->Portal.Get(index));
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
const PortalType &GetPortal() const { return this->Portal; }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
const FunctorType &GetFunctor() const { return this->Functor; }
@ -97,33 +103,37 @@ protected:
template<typename ValueType_, typename PortalType_,
typename FunctorType_, typename InverseFunctorType_>
class ArrayPortalExecTransform : public ArrayPortalExecTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
class ArrayPortalTransform : public ArrayPortalTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
{
public:
typedef ArrayPortalExecTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType> Superclass;
typedef ArrayPortalTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType> Superclass;
typedef PortalType_ PortalType;
typedef ValueType_ ValueType;
typedef FunctorType_ FunctorType;
typedef InverseFunctorType_ InverseFunctorType;
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalExecTransform(const PortalType &portal = PortalType(),
const FunctorType &functor = FunctorType(),
ArrayPortalTransform(const PortalType &portal = PortalType(),
const FunctorType &functor = FunctorType(),
const InverseFunctorType& inverseFunctor = InverseFunctorType())
: Superclass(portal,functor), InverseFunctor(inverseFunctor)
{ }
template<class OtherV, class OtherP, class OtherF, class OtherInvF>
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalExecTransform(const ArrayPortalExecTransform<OtherV,OtherP,OtherF,OtherInvF> &src)
ArrayPortalTransform(const ArrayPortalTransform<OtherV,OtherP,OtherF,OtherInvF> &src)
: Superclass(src), InverseFunctor(src.GetInverseFunctor())
{ }
VTKM_EXEC_EXPORT
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
void Set(vtkm::Id index, const ValueType& value) const {
return this->Portal.Set(index,this->InverseFunctor(value));
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
const InverseFunctorType &GetInverseFunctor() const {
return this->InverseFunctor; }
@ -143,94 +153,6 @@ namespace cont {
namespace internal {
/// \brief An array portal that transforms a value from another portal.
///
template<typename ValueType_, typename PortalType_, typename FunctorType_,
typename InverseFunctorType=NullFunctorType>
class ArrayPortalContTransform;
template<typename ValueType_, typename PortalType_, typename FunctorType_>
class ArrayPortalContTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
{
public:
typedef PortalType_ PortalType;
typedef ValueType_ ValueType;
typedef FunctorType_ FunctorType;
VTKM_CONT_EXPORT
ArrayPortalContTransform(const PortalType &portal = PortalType(),
const FunctorType &functor = FunctorType())
: Portal(portal), Functor(functor)
{ }
/// Copy constructor for any other ArrayPortalContTransform with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherP, class OtherF>
VTKM_CONT_EXPORT
ArrayPortalContTransform(const ArrayPortalContTransform<OtherV,OtherP,OtherF> &src)
: Portal(src.GetPortal()),
Functor(src.GetFunctor())
{ }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
return this->Portal.GetNumberOfValues();
}
VTKM_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return this->Functor(this->Portal.Get(index));
}
VTKM_CONT_EXPORT
const PortalType &GetPortal() const { return this->Portal; }
VTKM_CONT_EXPORT
const FunctorType &GetFunctor() const { return this->Functor; }
protected:
PortalType Portal;
FunctorType Functor;
};
template<typename ValueType_, typename PortalType_, typename FunctorType_,
typename InverseFunctorType_>
class ArrayPortalContTransform : public ArrayPortalContTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType>
{
public:
typedef ArrayPortalContTransform<ValueType_,PortalType_,FunctorType_,NullFunctorType> Superclass;
typedef PortalType_ PortalType;
typedef ValueType_ ValueType;
typedef FunctorType_ FunctorType;
typedef InverseFunctorType_ InverseFunctorType;
VTKM_CONT_EXPORT
ArrayPortalContTransform(const PortalType &portal = PortalType(),
const FunctorType &functor = FunctorType(),
const InverseFunctorType &inverseFunctor = InverseFunctorType())
: Superclass(portal,functor), InverseFunctor(inverseFunctor)
{ }
template<class OtherV, class OtherP, class OtherF, class OtherInvF>
VTKM_CONT_EXPORT
ArrayPortalContTransform(const ArrayPortalContTransform<OtherV,OtherP,OtherF,OtherInvF> &src)
: Superclass(src), InverseFunctor(src.GetInverseFunctor())
{ }
VTKM_CONT_EXPORT
void Set(vtkm::Id index, const ValueType& value) const {
this->Portal.Set(index,this->InverseFunctor(value));
}
VTKM_CONT_EXPORT
const InverseFunctorType &GetInverseFunctor() const { return this->InverseFunctor; }
private:
InverseFunctorType InverseFunctor;
};
template<typename ValueType, typename ArrayHandleType, typename FunctorType,
typename InverseFunctorType=NullFunctorType>
struct StorageTagTransform {};
@ -249,7 +171,7 @@ public:
typedef void *IteratorType;
};
typedef ArrayPortalContTransform<
typedef vtkm::exec::internal::ArrayPortalTransform<
ValueType, typename ArrayHandleType::PortalConstControl, FunctorType>
PortalConstType;
@ -325,10 +247,10 @@ class Storage<T,
public:
typedef T ValueType;
typedef ArrayPortalContTransform<ValueType,
typedef vtkm::exec::internal::ArrayPortalTransform<ValueType,
typename ArrayHandleType::PortalControl, FunctorType, InverseFunctorType>
PortalType;
typedef ArrayPortalContTransform<ValueType,
typedef vtkm::exec::internal::ArrayPortalTransform<ValueType,
typename ArrayHandleType::PortalConstControl,FunctorType,InverseFunctorType>
PortalConstType;
@ -421,7 +343,7 @@ public:
//meant to be an invalid writeable execution portal
typedef typename StorageType::PortalType PortalExecution;
typedef vtkm::exec::internal::ArrayPortalExecTransform<
typedef vtkm::exec::internal::ArrayPortalTransform<
ValueType,
typename ArrayHandleType::template ExecutionTypes<Device>::PortalConst,
FunctorType> PortalConstExecution;
@ -496,11 +418,11 @@ public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::exec::internal::ArrayPortalExecTransform<
typedef vtkm::exec::internal::ArrayPortalTransform<
ValueType,
typename ArrayHandleType::template ExecutionTypes<Device>::Portal,
FunctorType, InverseFunctorType> PortalExecution;
typedef vtkm::exec::internal::ArrayPortalExecTransform<
typedef vtkm::exec::internal::ArrayPortalTransform<
ValueType,
typename ArrayHandleType::template ExecutionTypes<Device>::PortalConst,
FunctorType, InverseFunctorType> PortalConstExecution;

75
vtkm/cont/ArrayHandleZip.h
View File

@ -32,7 +32,7 @@ namespace internal {
template<typename ValueType_,
typename PortalTypeFirst_,
typename PortalTypeSecond_>
class ArrayPortalExecZip
class ArrayPortalZip
{
public:
typedef ValueType_ ValueType;
@ -42,23 +42,23 @@ public:
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT_EXPORT
ArrayPortalExecZip()
ArrayPortalZip()
: PortalFirst(), PortalSecond()
{ } //needs to be host and device so that cuda can create lvalue of these
VTKM_CONT_EXPORT
ArrayPortalExecZip(const PortalTypeFirst &portalfirst,
const PortalTypeSecond &portalsecond)
ArrayPortalZip(const PortalTypeFirst &portalfirst,
const PortalTypeSecond &portalsecond)
: PortalFirst(portalfirst), PortalSecond(portalsecond)
{ }
/// Copy constructor for any other ArrayPortalExecZip with an iterator
/// Copy constructor for any other ArrayPortalZip with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherF, class OtherS>
VTKM_CONT_EXPORT
ArrayPortalExecZip(const ArrayPortalExecZip<OtherV,OtherF,OtherS> &src)
ArrayPortalZip(const ArrayPortalZip<OtherV,OtherF,OtherS> &src)
: PortalFirst(src.GetFirstPortal()),
PortalSecond(src.GetSecondPortal())
{ }
@ -100,61 +100,6 @@ namespace cont {
namespace internal {
/// \brief An array portal that zips two portals together into a single value
/// for the control environment
template<typename ValueType_,
typename PortalTypeFirst,
typename PortalTypeSecond>
class ArrayPortalContZip
{
public:
typedef ValueType_ ValueType;
typedef ValueType_ IteratorType;
VTKM_CONT_EXPORT
ArrayPortalContZip(const PortalTypeFirst &portalfirst = PortalTypeFirst(),
const PortalTypeSecond &portalsecond = PortalTypeSecond())
: PortalFirst(portalfirst), PortalSecond(portalsecond)
{ }
/// Copy constructor for any other ArrayPortalContZip with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherF, class OtherS>
VTKM_CONT_EXPORT
ArrayPortalContZip(const ArrayPortalContZip<OtherV,OtherF,OtherS> &src)
: PortalFirst(src.GetFirstPortal()),
PortalSecond(src.GetSecondPortal())
{ }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return this->PortalFirst.GetNumberOfValues(); }
VTKM_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return vtkm::make_Pair(this->PortalFirst.Get(index),
this->PortalSecond.Get(index));
}
VTKM_CONT_EXPORT
void Set(vtkm::Id index, const ValueType &value) const {
this->PortalFirst.Set(index, value.first);
this->PortalSecond.Set(index, value.second);
}
VTKM_CONT_EXPORT
const PortalTypeFirst &GetFirstPortal() const { return this->PortalFirst; }
VTKM_CONT_EXPORT
const PortalTypeSecond &GetSecondPortal() const { return this->PortalSecond; }
private:
PortalTypeFirst PortalFirst;
PortalTypeSecond PortalSecond;
};
template<typename FirstHandleType, typename SecondHandleType>
struct StorageTagZip { };
@ -187,10 +132,10 @@ class Storage<T, StorageTagZip<FirstHandleType, SecondHandleType > >
public:
typedef T ValueType;
typedef ArrayPortalContZip< ValueType,
typedef vtkm::exec::internal::ArrayPortalZip< ValueType,
typename FirstHandleType::PortalControl,
typename SecondHandleType::PortalControl> PortalType;
typedef ArrayPortalContZip< ValueType,
typedef vtkm::exec::internal::ArrayPortalZip< ValueType,
typename FirstHandleType::PortalConstControl,
typename SecondHandleType::PortalConstControl>
PortalConstType;
@ -273,13 +218,13 @@ public:
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::exec::internal::ArrayPortalExecZip<
typedef vtkm::exec::internal::ArrayPortalZip<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::Portal,
typename SecondHandleType::template ExecutionTypes<Device>::Portal
> PortalExecution;
typedef vtkm::exec::internal::ArrayPortalExecZip<
typedef vtkm::exec::internal::ArrayPortalZip<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::PortalConst,
typename SecondHandleType::template ExecutionTypes<Device>::PortalConst

5
vtkm/cont/ArrayPortal.h
View File

@ -50,9 +50,8 @@ namespace cont {
/// ArrayPortal objects. It is mostly an internal mechanism. However, an
/// ArrayPortal can be used to pass constant input data to an ArrayHandle.
///
/// Although this documentation is given for the control environment, there are
/// instances of an identical concept in the execution environment, although
/// some features are missing there.
/// Although portals are defined in the execution environment, they are also
/// used in the control environment for accessing data on the host.
///
template<typename T>
class ArrayPortal

3
vtkm/cont/CMakeLists.txt
View File

@ -37,6 +37,7 @@ set(headers
ArrayHandleZip.h
ArrayPortal.h
ArrayPortalToIterators.h
ArrayHandleConcatenate.h
CellSet.h
CellSetExplicit.h
CellSetListTag.h
@ -51,6 +52,7 @@ set(headers
DataSetFieldAdd.h
DeviceAdapter.h
DeviceAdapterAlgorithm.h
DeviceAdapterListTag.h
DeviceAdapterSerial.h
DynamicArrayHandle.h
DynamicCellSet.h
@ -69,6 +71,7 @@ set(headers
StorageImplicit.h
StorageListTag.h
Timer.h
TryExecute.h
)
#-----------------------------------------------------------------------------

13
vtkm/cont/CellSet.h
View File

@ -28,10 +28,6 @@
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
@ -90,16 +86,15 @@ protected:
namespace internal {
/// Checks to see if the given object is a cell set. This check is compatible
/// with the Boost meta-template programming library (MPL). It contains a
/// typedef named \c type that is either boost::mpl::true_ or
/// boost::mpl::false_. Both of these have a typedef named value with the
/// Checks to see if the given object is a cell set. It contains a
/// typedef named \c type that is either std::true_type or
/// std::false_type. Both of these have a typedef named value with the
/// respective boolean value.
///
template<typename T>
struct CellSetCheck
{
typedef typename boost::is_base_of<vtkm::cont::CellSet, T>::type type;
using type = typename std::is_base_of<vtkm::cont::CellSet, T>;
};
#define VTKM_IS_CELL_SET(T) \

4
vtkm/cont/CellSetExplicit.h
View File

@ -207,11 +207,11 @@ public:
this->ConnectivityLength = 0;
}
template <vtkm::IdComponent ItemTupleLength>
template <typename IndexableType>
VTKM_CONT_EXPORT
void AddCell(vtkm::UInt8 cellType,
vtkm::IdComponent numVertices,
const vtkm::Vec<vtkm::Id,ItemTupleLength> &ids)
const IndexableType &ids)
{
this->PointToCell.Shapes.GetPortalControl().Set(this->NumberOfCells, cellType);
this->PointToCell.NumIndices.GetPortalControl().Set(this->NumberOfCells, numVertices);

20
vtkm/cont/CoordinateSystem.h
View File

@ -83,6 +83,9 @@ class CoordinateSystem : public vtkm::cont::Field
typedef vtkm::cont::Field Superclass;
public:
VTKM_CONT_EXPORT
CoordinateSystem() : Superclass() { }
VTKM_CONT_EXPORT
CoordinateSystem(std::string name,
const vtkm::cont::DynamicArrayHandle &data)
@ -255,10 +258,23 @@ public:
}
};
template<typename Functor>
void CastAndCall(const vtkm::cont::CoordinateSystem& coords, const Functor &f)
{
coords.GetData().CastAndCall(f);
}
namespace internal {
template<>
struct DynamicTransformTraits<vtkm::cont::CoordinateSystem>
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
} // namespace internal
} // namespace cont
} // namespace vtkm
#endif //vtk_m_cont_CoordinateSystem_h

4
vtkm/cont/DataSet.h
View File

@ -227,7 +227,7 @@ public:
out<<" CellSets["<<this->GetNumberOfCellSets()<<"]\n";
for (vtkm::Id index = 0; index < this->GetNumberOfCellSets(); index++)
{
this->GetCellSet(index).GetCellSet().PrintSummary(out);
this->GetCellSet(index).PrintSummary(out);
}
out<<" Fields["<<this->GetNumberOfFields()<<"]\n";
@ -281,7 +281,7 @@ private:
{
for (std::size_t index=0; index < static_cast<size_t>(this->GetNumberOfCellSets()); ++index)
{
if (this->CellSets[index].GetCellSet().GetName() == name)
if (this->CellSets[index].GetName() == name)
{
found = true;
return static_cast<vtkm::Id>(index);

8
vtkm/cont/DataSetFieldAdd.h
View File

@ -133,7 +133,7 @@ public:
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
dataSet.GetCellSet(cellSetIndex).GetName();
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
template <typename T, typename Storage>
@ -145,7 +145,7 @@ public:
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
dataSet.GetCellSet(cellSetIndex).GetName();
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
template<typename T>
@ -157,7 +157,7 @@ public:
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
dataSet.GetCellSet(cellSetIndex).GetName();
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, cellSetName);
}
@ -170,7 +170,7 @@ public:
vtkm::Id cellSetIndex = 0)
{
std::string cellSetName =
dataSet.GetCellSet(cellSetIndex).GetCellSet().GetName();
dataSet.GetCellSet(cellSetIndex).GetName();
DataSetFieldAdd::AddCellField(dataSet, fieldName, field, n, cellSetName);
}

31
vtkm/cont/DeviceAdapterAlgorithm.h
View File

@ -50,13 +50,38 @@ struct DeviceAdapterAlgorithm
{
/// \brief Copy the contents of one ArrayHandle to another
///
/// Copies the contents of \c input to \c output. The array \c to will be
/// allocated to the appropriate size.
/// Copies the contents of \c input to \c output. The array \c output will be
/// allocated to the same size of \c input. If output has already been
/// allocated we will reallocate and clear any current values.
///
template<typename T, typename U, class CIn, class COut>
VTKM_CONT_EXPORT static void Copy(const vtkm::cont::ArrayHandle<T,CIn> &input,
vtkm::cont::ArrayHandle<U, COut> &output);
/// \brief Copy the contents of a section of one ArrayHandle to another
///
/// Copies the a range of elements of \c input to \c output. The number of
/// elements is determined by \c numberOfElementsToCopy, and initial start
/// position is determined by \c inputStartIndex. You can control where
/// in the destination the copy should occur by specifying the \c outputIndex
///
/// If inputStartIndex + numberOfElementsToCopy is greater than the length
/// of \c input we will only copy until we reach the end of the input array
///
/// If the \c outputIndex + numberOfElementsToCopy is greater than the
/// length of \c output we will reallocate the output array so it can
/// fit the number of elements we desire.
///
/// \par Requirements:
/// \arg \c input must already be sorted
///
template<typename T, typename U, class CIn, class COut>
VTKM_CONT_EXPORT static bool CopySubRange(const vtkm::cont::ArrayHandle<T,CIn> &input,
vtkm::Id inputStartIndex,
vtkm::Id numberOfElementsToCopy,
vtkm::cont::ArrayHandle<U, COut> &output,
vtkm::Id outputIndex = 0);
/// \brief Output is the first index in input for each item in values that wouldn't alter the ordering of input
///
/// LowerBounds is a vectorized search. From each value in \c values it finds
@ -513,7 +538,7 @@ public:
retval.Microseconds = 1000*currentTime.millitm;
#else
timeval currentTime;
gettimeofday(&currentTime, NULL);
gettimeofday(&currentTime, nullptr);
retval.Seconds = currentTime.tv_sec;
retval.Microseconds = currentTime.tv_usec;
#endif

46
vtkm/cont/DeviceAdapterListTag.h Normal file
View File

@ -0,0 +1,46 @@
//============================================================================
// 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 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 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.
//============================================================================
#ifndef vtk_m_cont_DeviceAdapterListTag_h
#define vtk_m_cont_DeviceAdapterListTag_h
#ifndef VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG
#define VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG \
::vtkm::cont::DeviceAdapterListTagCommon
#endif
#include <vtkm/ListTag.h>
#include <vtkm/cont/DeviceAdapterSerial.h>
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>
#include <vtkm/cont/tbb/DeviceAdapterTBB.h>
namespace vtkm {
namespace cont {
struct DeviceAdapterListTagCommon
: vtkm::ListTagBase<
vtkm::cont::DeviceAdapterTagCuda,
vtkm::cont::DeviceAdapterTagTBB,
vtkm::cont::DeviceAdapterTagSerial> { };
}
} // namespace vtkm::cont
#endif //vtk_m_cont_DeviceAdapterListTag_h

37
vtkm/cont/DynamicArrayHandle.h
View File

@ -29,11 +29,6 @@
#include <vtkm/cont/internal/DynamicTransform.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/utility/enable_if.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
@ -55,7 +50,7 @@ struct PolymorphicArrayHandleContainerBase
virtual void PrintSummary(std::ostream &out) const = 0;
virtual boost::shared_ptr<PolymorphicArrayHandleContainerBase>
virtual std::shared_ptr<PolymorphicArrayHandleContainerBase>
NewInstance() const = 0;
};
@ -97,10 +92,10 @@ struct PolymorphicArrayHandleContainer
vtkm::cont::printSummary_ArrayHandle(this->Array, out);
}
virtual boost::shared_ptr<PolymorphicArrayHandleContainerBase>
virtual std::shared_ptr<PolymorphicArrayHandleContainerBase>
NewInstance() const
{
return boost::shared_ptr<PolymorphicArrayHandleContainerBase>(
return std::shared_ptr<PolymorphicArrayHandleContainerBase>(
new PolymorphicArrayHandleContainer<T,Storage>());
}
};
@ -114,7 +109,7 @@ struct DynamicArrayHandleCopyHelper {
template<typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
static
const boost::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>&
const std::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>&
GetArrayHandleContainer(const vtkm::cont::DynamicArrayHandleBase<TypeList,StorageList> &src)
{
return src.ArrayContainer;
@ -123,7 +118,7 @@ struct DynamicArrayHandleCopyHelper {
// A simple function to downcast an ArrayHandle encapsulated in a
// PolymorphicArrayHandleContainerBase to the given type of ArrayHandle. If the
// conversion cannot be done, NULL is returned.
// conversion cannot be done, nullptr is returned.
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<Type,Storage> *
@ -134,13 +129,13 @@ DynamicArrayHandleTryCast(
downcastContainer = dynamic_cast<
vtkm::cont::detail::PolymorphicArrayHandleContainer<Type,Storage> *>(
arrayContainer);
if (downcastContainer != NULL)
if (downcastContainer != nullptr)
{
return &downcastContainer->Array;
}
else
{
return NULL;
return nullptr;
}
}
@ -148,7 +143,7 @@ template<typename Type, typename Storage>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<Type,Storage> *
DynamicArrayHandleTryCast(
const boost::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>& arrayContainer)
const std::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>& arrayContainer)
{
return detail::DynamicArrayHandleTryCast<Type,Storage>(arrayContainer.get());
}
@ -234,14 +229,14 @@ public:
bool IsTypeAndStorage() const {
return (
detail::DynamicArrayHandleTryCast<Type,Storage>(this->ArrayContainer)
!= NULL);
!= nullptr);
}
/// Returns true if this array matches the array handle type passed in.
///
template<typename ArrayHandleType>
VTKM_CONT_EXPORT
bool IsArrayHandleType()
bool IsType()
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
typedef typename ArrayHandleType::ValueType ValueType;
@ -257,7 +252,7 @@ public:
bool IsSameType(const ArrayHandleType &)
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
return this->IsArrayHandleType<ArrayHandleType>();
return this->IsType<ArrayHandleType>();
}
/// Returns this array cast to an ArrayHandle object of the given type and
@ -271,7 +266,7 @@ public:
CastToTypeStorage() const {
vtkm::cont::ArrayHandle<Type, Storage> *downcastArray =
detail::DynamicArrayHandleTryCast<Type,Storage>(this->ArrayContainer);
if (downcastArray == NULL)
if (downcastArray == nullptr)
{
throw vtkm::cont::ErrorControlBadType("Bad cast of dynamic array.");
}
@ -282,7 +277,7 @@ public:
}
/// Returns this array cast to the given \c ArrayHandle type. Throws \c
/// ErrorControlBadType if the cast does not work. Use \c IsArrayHandleType
/// ErrorControlBadType if the cast does not work. Use \c IsType
/// to check if the cast can happen.
///
template<typename ArrayHandleType>
@ -410,7 +405,7 @@ public:
}
private:
boost::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>
std::shared_ptr<vtkm::cont::detail::PolymorphicArrayHandleContainerBase>
ArrayContainer;
friend struct detail::DynamicArrayHandleCopyHelper;
@ -442,7 +437,7 @@ struct DynamicArrayHandleTryStorage {
private:
template<typename Storage>
void DoCast(Storage, boost::mpl::bool_<true>)
void DoCast(Storage, std::true_type)
{
if (!this->FoundCast &&
this->Array->template IsTypeAndStorage<Type,Storage>())
@ -453,7 +448,7 @@ private:
}
template<typename Storage>
void DoCast(Storage, boost::mpl::bool_<false>)
void DoCast(Storage, std::false_type)
{
// This type of array handle cannot exist, so do nothing.
}

61
vtkm/cont/DynamicCellSet.h
View File

@ -27,10 +27,6 @@
#include <vtkm/cont/internal/DynamicTransform.h>
#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/smart_ptr/shared_ptr.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
@ -49,7 +45,7 @@ struct DynamicCellSetCopyHelper {
template<typename CellSetList>
VTKM_CONT_EXPORT
static
const boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>&
const std::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>&
GetCellSetContainer(const vtkm::cont::DynamicCellSetBase<CellSetList> &src)
{
return src.CellSetContainer;
@ -58,7 +54,7 @@ struct DynamicCellSetCopyHelper {
// A simple function to downcast a CellSet encapsulated in a
// SimplePolymorphicContainerBase to the given subclass of CellSet. If the
// conversion cannot be done, NULL is returned.
// conversion cannot be done, nullptr is returned.
template<typename CellSetType>
VTKM_CONT_EXPORT
CellSetType *
@ -69,13 +65,13 @@ DynamicCellSetTryCast(
downcastContainer = dynamic_cast<
vtkm::cont::internal::SimplePolymorphicContainer<CellSetType> *>(
cellSetContainer);
if (downcastContainer != NULL)
if (downcastContainer != nullptr)
{
return &downcastContainer->Item;
}
else
{
return NULL;
return nullptr;
}
}
@ -83,7 +79,7 @@ template<typename CellSetType>
VTKM_CONT_EXPORT
CellSetType *
DynamicCellSetTryCast(
const boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>& cellSetContainer)
const std::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>& cellSetContainer)
{
return detail::DynamicCellSetTryCast<CellSetType>(cellSetContainer.get());
}
@ -166,7 +162,7 @@ public:
VTKM_CONT_EXPORT
bool IsType() const {
return (detail::DynamicCellSetTryCast<CellSetType>(this->CellSetContainer)
!= NULL);
!= nullptr);
}
/// Returns true if this cell set is the same (or equivalent) type as the
@ -181,7 +177,7 @@ public:
/// Returns the contained cell set as the abstract \c CellSet type.
///
VTKM_CONT_EXPORT
const vtkm::cont::CellSet &GetCellSet() const {
const vtkm::cont::CellSet &CastToBase() const {
return *reinterpret_cast<const vtkm::cont::CellSet *>(
this->CellSetContainer->GetVoidPointer());
}
@ -195,7 +191,7 @@ public:
CellSetType &Cast() const {
CellSetType *cellSetPointer =
detail::DynamicCellSetTryCast<CellSetType>(this->CellSetContainer);
if (cellSetPointer == NULL)
if (cellSetPointer == nullptr)
{
throw vtkm::cont::ErrorControlBadType("Bad cast of dynamic cell set.");
}
@ -257,8 +253,45 @@ public:
return newCellSet;
}
VTKM_CONT_EXPORT
virtual std::string GetName() const
{
return this->CastToBase().GetName();
}
VTKM_CONT_EXPORT
virtual vtkm::Id GetNumberOfCells() const
{
return this->CastToBase().GetNumberOfCells();
}
VTKM_CONT_EXPORT
virtual vtkm::Id GetNumberOfFaces() const
{
return this->CastToBase().GetNumberOfFaces();
}
VTKM_CONT_EXPORT
virtual vtkm::Id GetNumberOfEdges() const
{
return this->CastToBase().GetNumberOfEdges();
}
VTKM_CONT_EXPORT
virtual vtkm::Id GetNumberOfPoints() const
{
return this->CastToBase().GetNumberOfPoints();
}
VTKM_CONT_EXPORT
virtual void PrintSummary(std::ostream& stream) const
{
return this->CastToBase().PrintSummary(stream);
}
private:
boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
std::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
CellSetContainer;
friend struct detail::DynamicCellSetCopyHelper;
@ -286,7 +319,7 @@ struct DynamicCellSetTryCellSet
{
CellSetType *cellSet =
detail::DynamicCellSetTryCast<CellSetType>(this->CellSetContainer);
if (cellSet != NULL)
if (cellSet != nullptr)
{
this->Function(*cellSet);
this->FoundCast = true;

14
vtkm/cont/Field.h
View File

@ -518,7 +518,21 @@ private:
mutable bool ModifiedFlag;
};
template<typename Functor>
void CastAndCall(const vtkm::cont::Field& field, const Functor &f)
{
field.GetData().CastAndCall(f);
}
namespace internal {
template<>
struct DynamicTransformTraits<vtkm::cont::Field>
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
} // namespace internal
} // namespace cont
} // namespace vtkm

39
vtkm/cont/StorageBasic.h
View File

@ -61,9 +61,9 @@ namespace internal {
inline void* alloc_aligned(size_t size, size_t align){
#if defined(VTKM_MEMALIGN_POSIX)
void *mem = NULL;
void *mem = nullptr;
if (posix_memalign(&mem, align, size) != 0){
mem = NULL;
mem = nullptr;
}
#elif defined(VTKM_MEMALIGN_WIN)
void *mem = _aligned_malloc(size, align);
@ -72,7 +72,7 @@ inline void* alloc_aligned(size_t size, size_t align){
#else
void *mem = malloc(size);
#endif
if (mem == NULL){
if (mem == nullptr){
throw std::bad_alloc();
}
return mem;
@ -174,12 +174,12 @@ public:
public:
VTKM_CONT_EXPORT
Storage(const ValueType *array = NULL, vtkm::Id numberOfValues = 0)
Storage(const ValueType *array = nullptr, vtkm::Id numberOfValues = 0)
: Array(const_cast<ValueType *>(array)),
NumberOfValues(numberOfValues),
AllocatedSize(numberOfValues),
DeallocateOnRelease(false),
UserProvidedMemory( array == NULL ? false : true)
UserProvidedMemory( array == nullptr ? false : true)
{
}
@ -230,20 +230,20 @@ public:
{
if (this->NumberOfValues > 0)
{
VTKM_ASSERT(this->Array != NULL);
VTKM_ASSERT(this->Array != nullptr);
if (this->DeallocateOnRelease)
{
AllocatorType allocator;
allocator.deallocate(this->Array,
static_cast<std::size_t>(this->AllocatedSize) );
}
this->Array = NULL;
this->Array = nullptr;
this->NumberOfValues = 0;
this->AllocatedSize = 0;
}
else
{
VTKM_ASSERT(this->Array == NULL);
VTKM_ASSERT(this->Array == nullptr);
}
}
@ -281,7 +281,7 @@ public:
catch (std::bad_alloc err)
{
// Make sureour state is OK.
this->Array = NULL;
this->Array = nullptr;
this->NumberOfValues = 0;
this->AllocatedSize = 0;
throw vtkm::cont::ErrorControlBadAllocation(
@ -322,10 +322,27 @@ public:
return PortalConstType(this->Array, this->Array + this->NumberOfValues);
}
/// \brief Get a pointer to the underlying data structure.
///
/// This method returns the pointer to the array held by this array. The
/// memory associated with this array still belongs to the Storage (i.e.
/// Storage will eventually deallocate the array).
///
VTKM_CONT_EXPORT
ValueType *GetArray()
{
return this->Array;
}
VTKM_CONT_EXPORT
const ValueType *GetArray() const
{
return this->Array;
}
/// \brief Take the reference away from this object.
///
/// This method returns the pointer to the array held by this array. It then
/// clears the internal array pointer to NULL, thereby ensuring that the
/// clears the internal array pointer to nullptr, thereby ensuring that the
/// Storage will never deallocate the array. This is helpful for taking a
/// reference for an array created internally by VTK-m and not having to keep
/// a VTK-m object around. Obviously the caller becomes responsible for
@ -335,7 +352,7 @@ public:
ValueType *StealArray()
{
ValueType *saveArray = this->Array;
this->Array = NULL;
this->Array = nullptr;
this->NumberOfValues = 0;
this->AllocatedSize = 0;
return saveArray;

208
vtkm/cont/TryExecute.h Normal file
View File

@ -0,0 +1,208 @@
//============================================================================
// 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 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 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.
//============================================================================
#ifndef vtk_m_cont_TryExecute_h
#define vtk_m_cont_TryExecute_h
#include <vtkm/cont/DeviceAdapterListTag.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
namespace vtkm {
namespace cont {
namespace detail {
template<typename Functor, typename Device, bool DeviceAdapterValid>
struct TryExecuteRunIfValid;
template<typename Functor, typename Device>
struct TryExecuteRunIfValid<Functor, Device, false>
{
VTKM_CONT_EXPORT
static bool Run(Functor &, vtkm::cont::internal::RuntimeDeviceTracker &) {
return false;
}
};
template<typename Functor, typename Device>
struct TryExecuteRunIfValid<Functor, Device, true>
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
VTKM_CONT_EXPORT
static bool Run(Functor &functor,
vtkm::cont::internal::RuntimeDeviceTracker &tracker)
{
if (tracker.CanRunOn(Device()))
{
try
{
return functor(Device());
}
catch(vtkm::cont::ErrorControlBadAllocation e)
{
std::cerr << "caught ErrorControlBadAllocation " << e.GetMessage() << std::endl;
//currently we only consider OOM errors worth disabling a device for
//than we fallback to another device
tracker.ReportAllocationFailure(Device(), e);
}
catch(vtkm::cont::ErrorControlBadType e)
{
//should bad type errors should stop the execution, instead of
//deferring to another device adapter?
std::cerr << "caught ErrorControlBadType : " << e.GetMessage() << std::endl;
}
catch(vtkm::cont::ErrorControlBadValue e)
{
//should bad value errors should stop the filter, instead of deferring
//to another device adapter?
std::cerr << "caught ErrorControlBadValue : " << e.GetMessage() << std::endl;
}
catch(vtkm::cont::Error e)
{
//general errors should be caught and let us try the next device adapter.
std::cerr << "exception is: " << e.GetMessage() << std::endl;
}
catch (std::exception e)
{
std::cerr << "caught standard exception: " << e.what() << std::endl;
}
catch (...)
{
std::cerr << "unknown exception caught" << std::endl;
}
}
// If we are here, then the functor was either never run or failed.
return false;
}
};
template<typename FunctorType>
struct TryExecuteImpl
{
// Warning, these are a references. Make sure referenced objects do not go
// out of scope.
FunctorType &Functor;
vtkm::cont::internal::RuntimeDeviceTracker &Tracker;
bool Success;
VTKM_CONT_EXPORT
TryExecuteImpl(FunctorType &functor,
vtkm::cont::internal::RuntimeDeviceTracker &tracker)
: Functor(functor), Tracker(tracker), Success(false) { }
template<typename Device>
VTKM_CONT_EXPORT
bool operator()(Device)
{
if (!this->Success)
{
typedef vtkm::cont::DeviceAdapterTraits<Device> DeviceTraits;
this->Success =
detail::TryExecuteRunIfValid<FunctorType,Device,DeviceTraits::Valid>
::Run(this->Functor, this->Tracker);
}
return this->Success;
}
};
} // namespace detail
/// \brief Try to execute a functor on a list of devices until one succeeds.
///
/// This function takes a functor and a list of devices. It then tries to run
/// the functor for each device (in the order given in the list) until the
/// execution succeeds.
///
/// The functor parentheses operator should take exactly one argument, which is
/// the \c DeviceAdapterTag to use. The functor should return a \c bool that is
/// \c true if the execution succeeds, \c false if it fails. If an exception is
/// thrown from the functor, then the execution is assumed to have failed.
///
/// This function also optionally takes a \c RuntimeDeviceTracker, which will
/// monitor for certain failures across calls to TryExecute and skip trying
/// devices with a history of failure.
///
/// This function returns \c true if the functor succeeded on a device,
/// \c false otherwise.
///
/// If no device list is specified, then \c VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG
/// is used.
///
template<typename Functor, typename DeviceList>
VTKM_CONT_EXPORT
bool TryExecute(const Functor &functor,
vtkm::cont::internal::RuntimeDeviceTracker &tracker,
DeviceList)
{
detail::TryExecuteImpl<const Functor> internals(functor, tracker);
vtkm::ListForEach(internals, DeviceList());
return internals.Success;
}
template<typename Functor, typename DeviceList>
VTKM_CONT_EXPORT
bool TryExecute(Functor &functor,
vtkm::cont::internal::RuntimeDeviceTracker &tracker,
DeviceList)
{
detail::TryExecuteImpl<Functor> internals(functor, tracker);
vtkm::ListForEach(internals, DeviceList());
return internals.Success;
}
template<typename Functor, typename DeviceList>
VTKM_CONT_EXPORT
bool TryExecute(const Functor &functor, DeviceList)
{
vtkm::cont::internal::RuntimeDeviceTracker tracker;
return vtkm::cont::TryExecute(functor, tracker, DeviceList());
}
template<typename Functor, typename DeviceList>
VTKM_CONT_EXPORT
bool TryExecute(Functor &functor, DeviceList)
{
vtkm::cont::internal::RuntimeDeviceTracker tracker;
return vtkm::cont::TryExecute(functor, tracker, DeviceList());
}
template<typename Functor>
VTKM_CONT_EXPORT
bool TryExecute(const Functor &functor)
{
return vtkm::cont::TryExecute(functor,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
}
template<typename Functor>
VTKM_CONT_EXPORT
bool TryExecute(Functor &functor)
{
return vtkm::cont::TryExecute(functor,
VTKM_DEFAULT_DEVICE_ADAPTER_LIST_TAG());
}
}
} // namespace vtkm::cont
#endif //vtk_m_cont_TryExecute_h

8
vtkm/cont/arg/ControlSignatureTagBase.h
View File

@ -23,9 +23,7 @@
#include <vtkm/StaticAssert.h>
#include <vtkm/internal/ExportMacros.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <type_traits>
namespace vtkm {
namespace cont {
@ -49,8 +47,8 @@ namespace internal {
template<typename ControlSignatureTag>
struct ControlSignatureTagCheck
{
static const bool Valid =
boost::is_base_of<
static VTKM_CONSTEXPR bool Valid =
std::is_base_of<
vtkm::cont::arg::ControlSignatureTagBase, ControlSignatureTag>::value;
};

9
vtkm/cont/arg/TransportTagExecObject.h
View File

@ -26,11 +26,6 @@
#include <vtkm/exec/ExecutionObjectBase.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/mpl/assert.hpp>
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
namespace vtkm {
namespace cont {
namespace arg {
@ -49,7 +44,9 @@ struct Transport<vtkm::cont::arg::TransportTagExecObject,ContObjectType,Device>
// is not an execution object as an argument that is expected to be one. All
// execution objects are expected to inherit from
// vtkm::exec::ExecutionObjectBase.
BOOST_MPL_ASSERT(( boost::is_base_of<vtkm::exec::ExecutionObjectBase, ContObjectType> ));
static_assert(
std::is_base_of<vtkm::exec::ExecutionObjectBase, ContObjectType>::value,
"All execution objects are expected to inherit from vtkm::exec::ExecutionObjectBase");
typedef ContObjectType ExecObjectType;

8
vtkm/cont/arg/TypeCheckTagExecObject.h
View File

@ -26,9 +26,7 @@
#include <vtkm/exec/ExecutionObjectBase.h>
VTKM_THIRDPARTY_PRE_INCLUDE
#include <boost/type_traits/is_base_of.hpp>
VTKM_THIRDPARTY_POST_INCLUDE
#include <type_traits>
namespace vtkm {
namespace cont {
@ -43,8 +41,8 @@ struct TypeCheckTagExecObject { };
template<typename Type>
struct TypeCheck<TypeCheckTagExecObject, Type>
{
static const bool value =
boost::is_base_of<vtkm::exec::ExecutionObjectBase, Type>::value;
static VTKM_CONSTEXPR bool value =
std::is_base_of<vtkm::exec::ExecutionObjectBase, Type>::value;
};
}

2
vtkm/cont/arg/testing/UnitTestTransportArrayIn.cxx
View File

@ -79,7 +79,7 @@ struct TryArrayInType
template<typename Device>
void TryArrayInTransport(Device)
{
vtkm::testing::Testing::TryAllTypes(TryArrayInType<Device>());
vtkm::testing::Testing::TryTypes(TryArrayInType<Device>());
}
void TestArrayInTransport()

2
vtkm/cont/arg/testing/UnitTestTransportArrayOut.cxx
View File

@ -75,7 +75,7 @@ struct TryArrayOutType
template<typename Device>
void TryArrayOutTransport(Device)
{
vtkm::testing::Testing::TryAllTypes(TryArrayOutType<Device>());
vtkm::testing::Testing::TryTypes(TryArrayOutType<Device>());
}
void TestArrayOutTransport()

2
vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx
View File

@ -99,7 +99,7 @@ void TestCheckAtomicArray()
void TestCheckArray()
{
vtkm::testing::Testing::TryAllTypes(TryArraysOfType());
vtkm::testing::Testing::TryTypes(TryArraysOfType());
std::cout << "Trying some arrays with types that do not match the list."
<< std::endl;

88
vtkm/cont/cuda/internal/DeviceAdapterAlgorithmThrust.h
View File

@ -288,7 +288,7 @@ private:
#endif
template<class InputPortal, class OutputPortal>
VTKM_CONT_EXPORT static void CopyPortal(const InputPortal &input,
const OutputPortal &output)
const OutputPortal &output)
{
try
{
@ -303,6 +303,26 @@ private:
}
}
template<class InputPortal, class OutputPortal>
VTKM_CONT_EXPORT static void CopySubRangePortal(const InputPortal &input,
vtkm::Id inputOffset,
vtkm::Id size,
const OutputPortal &output,
vtkm::Id outputOffset)
{
try
{
::thrust::copy_n(thrust::cuda::par,
IteratorBegin(input)+inputOffset,
static_cast<std::size_t>(size),
IteratorBegin(output)+outputOffset);
}
catch(...)
{
throwAsVTKmException();
}
}
template<class InputPortal, class ValuesPortal, class OutputPortal>
VTKM_CONT_EXPORT static void LowerBoundsPortal(const InputPortal &input,
const ValuesPortal &values,
@ -778,15 +798,57 @@ public:
const vtkm::cont::ArrayHandle<T,SIn> &input,
vtkm::cont::ArrayHandle<U,SOut> &output)
{
const vtkm::Id numberOfValues = input.GetNumberOfValues();
//We need call PrepareForInput on the input argument before invoking a
//function. The order of execution of parameters of a function is undefined
//so we need to make sure input is called before output, or else in-place
//use case breaks.
input.PrepareForInput(DeviceAdapterTag());
const vtkm::Id inSize = input.GetNumberOfValues();
CopyPortal(input.PrepareForInput(DeviceAdapterTag()),
output.PrepareForOutput(numberOfValues, DeviceAdapterTag()));
output.PrepareForOutput(inSize, DeviceAdapterTag()));
}
template<typename T, typename U, class SIn, class SOut>
VTKM_CONT_EXPORT static bool CopySubRange(
const vtkm::cont::ArrayHandle<T,SIn> &input,
vtkm::Id inputStartIndex,
vtkm::Id numberOfElementsToCopy,
vtkm::cont::ArrayHandle<U,SOut> &output,
vtkm::Id outputIndex = 0)
{
const vtkm::Id inSize = input.GetNumberOfValues();
if(inputStartIndex < 0 ||
numberOfElementsToCopy < 0 ||
outputIndex < 0 ||
inputStartIndex >= inSize)
{ //invalid parameters
return false;
}
//determine if the numberOfElementsToCopy needs to be reduced
if(inSize < (inputStartIndex + numberOfElementsToCopy))
{ //adjust the size
numberOfElementsToCopy = (inSize - inputStartIndex);
}
const vtkm::Id outSize = output.GetNumberOfValues();
const vtkm::Id copyOutEnd = outputIndex + numberOfElementsToCopy;
if(outSize < copyOutEnd)
{ //output is not large enough
if(outSize == 0)
{ //since output has nothing, just need to allocate to correct length
output.Allocate(copyOutEnd);
}
else
{ //we currently have data in this array, so preserve it in the new
//resized array
vtkm::cont::ArrayHandle<U, SOut> temp;
temp.Allocate(copyOutEnd);
CopySubRange(output, 0, outSize, temp);
output = temp;
}
}
CopySubRangePortal(input.PrepareForInput(DeviceAdapterTag()),
inputStartIndex,
numberOfElementsToCopy,
output.PrepareForInPlace(DeviceAdapterTag()),
outputIndex);
return true;
}
template<typename T, class SIn, class SVal, class SOut>
@ -984,8 +1046,8 @@ private:
{
const vtkm::Id ERROR_ARRAY_SIZE = 1024;
static bool errorArrayInit = false;
static char* hostPtr = NULL;
static char* devicePtr = NULL;
static char* hostPtr = nullptr;
static char* devicePtr = nullptr;
if( !errorArrayInit )
{
cudaMallocHost( (void**)&hostPtr, ERROR_ARRAY_SIZE, cudaHostAllocMapped );
@ -1047,7 +1109,7 @@ public:
//since the memory is pinned we can access it safely on the host
//without a memcpy
vtkm::Id errorArraySize = 0;
char* hostErrorPtr = NULL;
char* hostErrorPtr = nullptr;
char* deviceErrorPtr = GetPinnedErrorArray(errorArraySize, &hostErrorPtr);
//clear the first character which means that we don't contain an error
@ -1106,7 +1168,7 @@ public:
//since the memory is pinned we can access it safely on the host
//without a memcpy
vtkm::Id errorArraySize = 0;
char* hostErrorPtr = NULL;
char* hostErrorPtr = nullptr;
char* deviceErrorPtr = GetPinnedErrorArray(errorArraySize, &hostErrorPtr);
//clear the first character which means that we don't contain an error

4
vtkm/cont/cuda/testing/UnitTestCudaArrayHandle.cu
View File

@ -37,12 +37,12 @@ void TestCudaHandle()
{
//Verify that we can construct a cuda array handle using the class inside
//the vtkm::cont::cuda namespace
vtkm::cont::cuda::ArrayHandle<vtkm::Id> handleFoo(NULL,0);
vtkm::cont::cuda::ArrayHandle<vtkm::Id> handleFoo(nullptr,0);
vtkm::cont::Field foo("foo", vtkm::cont::Field::ASSOC_CELL_SET , "cellset", handleFoo);
//Verify that we can construct a cuda array handle using the class inside
//the vtkm::cont namespace
vtkm::cont::ArrayHandleCuda< vtkm::Vec< vtkm::Float32, 3> > handleBar(NULL,0);
vtkm::cont::ArrayHandleCuda< vtkm::Vec< vtkm::Float32, 3> > handleBar(nullptr,0);
vtkm::cont::Field bar("bar", vtkm::cont::Field::ASSOC_CELL_SET, "cellset", handleBar);
}

12
vtkm/cont/internal/ArrayPortalFromIterators.h
View File

@ -29,7 +29,7 @@
#include <iterator>
#include <limits>
#include <boost/type_traits.hpp>
#include <type_traits>
namespace vtkm {
namespace cont {
@ -43,8 +43,8 @@ class ArrayPortalFromIterators;
///
template<class IteratorT>
class ArrayPortalFromIterators<IteratorT,
typename boost::disable_if<
boost::is_const< typename boost::remove_pointer<IteratorT>::type > >::type>
typename std::enable_if<
!std::is_const< typename std::remove_pointer<IteratorT>::type >::value >::type >
{
public:
typedef typename std::iterator_traits<IteratorT>::value_type ValueType;
@ -127,8 +127,8 @@ private:
template<class IteratorT>
class ArrayPortalFromIterators<IteratorT,
typename boost::enable_if<
boost::is_const< typename boost::remove_pointer<IteratorT>::type > >::type>
typename std::enable_if<
std::is_const< typename std::remove_pointer<IteratorT>::type >::value >::type >
{
public:
typedef typename std::iterator_traits<IteratorT>::value_type ValueType;
@ -261,7 +261,7 @@ public:
std::advance(iterator, static_cast<difference_type>(this->NumberOfValues));
#else
//Visual Studio checked iterators throw exceptions when you try to advance
//NULL iterators even if the advancement length is zero. So instead
//nullptr iterators even if the advancement length is zero. So instead
//don't do the advancement at all
if(this->NumberOfValues > 0)
{

Some files were not shown because too many files have changed in this diff Show More