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 external-face-more-generic

Browse Source 
Update exception methods to new names.
This commit is contained in:
Kenneth Moreland 2017-02-08 16:55:58 -07:00
commit dcbbb72784
112 changed files with 1494 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitattributes vendored Normal file
View File

@ -0,0 +1,2 @@
data/* filter=lfs diff=lfs merge=lfs -text
/**/data/* filter=lfs diff=lfs merge=lfs -text

15
CMake/FindEGL.cmake
View File

@ -21,7 +21,7 @@
# Once done this will define
#
# EGL_FOUND - true if EGL has been found
# EGL_INCLUDE_DIR - where the EGL/egl.h and KHR/khrplatform.h can be found
# EGL_INCLUDE_DIRS - where the EGL/egl.h and KHR/khrplatform.h can be found
# EGL_LIBRARY - link this to use libEGL.so.1
# EGL_opengl_LIBRARY - link with these two libraries instead of the gl library
# EGL_gldispatch_LIBRARY for full OpenGL support through EGL
@ -102,10 +102,15 @@ if(NOT EGL_gldispatch_LIBRARY)
endif()
endif()
set(EGL_LIBRARIES ${EGL_LIBRARY} ${EGL_opengl_LIBRARY} ${EGL_gldispatch_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(EGL DEFAULT_MSG
EGL_LIBRARY EGL_opengl_LIBRARY EGL_gldispatch_LIBRARY EGL_INCLUDE_DIR)
find_package_handle_standard_args(EGL
FOUND_VAR EGL_FOUND
REQUIRED_VARS EGL_LIBRARY EGL_opengl_LIBRARY EGL_gldispatch_LIBRARY EGL_INCLUDE_DIR)
if(EGL_FOUND)
set(EGL_LIBRARIES ${EGL_LIBRARY} ${EGL_opengl_LIBRARY} ${EGL_gldispatch_LIBRARY})
set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
endif()
mark_as_advanced(EGL_DIR EGL_INCLUDE_DIR EGL_LIBRARY EGL_opengl_LIBRARY EGL_gldispatch_LIBRARY)

10
CMake/FindGLEW.cmake
View File

@ -64,15 +64,17 @@
#
# * Kitware, Inc.
find_path(GLEW_INCLUDE_DIR GL/glew.h)
find_library(GLEW_LIBRARY NAMES GLEW glew32 glew glew32s PATH_SUFFIXES lib64)
set(GLEW_INCLUDE_DIRS ${GLEW_INCLUDE_DIR})
set(GLEW_LIBRARIES ${GLEW_LIBRARY})
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GLEW
FOUND_VAR GLEW_FOUND
REQUIRED_VARS GLEW_INCLUDE_DIR GLEW_LIBRARY)
if(GLEW_FOUND)
set(GLEW_INCLUDE_DIRS ${GLEW_INCLUDE_DIR})
set(GLEW_LIBRARIES ${GLEW_LIBRARY})
endif()
mark_as_advanced(GLEW_INCLUDE_DIR GLEW_LIBRARY)

15
CMake/FindGLFW.cmake
View File

@ -23,8 +23,8 @@
# Once done this will define
#
# GLFW_FOUND
# GLFW_INCLUDE_DIR
# GLFW_LIBRARY
# GLFW_INCLUDE_DIRS
# GLFW_LIBRARIES
#
include(FindPackageHandleStandardArgs)
@ -94,9 +94,14 @@ if (${CMAKE_HOST_UNIX})
DOC "The GLFW library")
endif ()
find_package_handle_standard_args(GLFW DEFAULT_MSG
GLFW_INCLUDE_DIR
GLFW_LIBRARY
find_package_handle_standard_args(GLFW
FOUND_VAR GLFW_FOUND
REQUIRED_VARS GLFW_INCLUDE_DIR GLFW_LIBRARY
)
if(GLFW_FOUND)
set(GLFW_LIBRARIES ${GLFW_LIBRARY})
set(GLFW_INCLUDE_DIRS ${GLFW_INCLUDE_DIR})
endif()
mark_as_advanced( GLFW_INCLUDE_DIR GLFW_LIBRARY )

6
CMake/FindThrust.cmake
View File

@ -69,9 +69,13 @@ endif()
# Check for required components
include( FindPackageHandleStandardArgs )
find_package_handle_standard_args( Thrust
FOUND_VAR Thrust_FOUND
REQUIRED_VARS THRUST_INCLUDE_DIR
VERSION_VAR THRUST_VERSION
)
set(THRUST_INCLUDE_DIRS ${THRUST_INCLUDE_DIR})
if(Thrust_FOUND)
set(THRUST_INCLUDE_DIRS ${THRUST_INCLUDE_DIR})
endif()
mark_as_advanced(THRUST_INCLUDE_DIR)

31
CMake/VTKmConfigureComponents.cmake
View File

@ -71,7 +71,7 @@ macro(vtkm_finish_configure_component component)
if(NOT VTKm_${component}_FOUND)
cmake_parse_arguments(VTKm_FCC
""
"IS_BACKEND"
""
"DEPENDENT_VARIABLES;ADD_INCLUDES;ADD_LIBRARIES"
${ARGN}
@ -89,6 +89,10 @@ macro(vtkm_finish_configure_component component)
if (VTKm_${component}_FOUND)
set(VTKm_INCLUDE_DIRS ${VTKm_INCLUDE_DIRS} ${VTKm_FCC_ADD_INCLUDES})
set(VTKm_LIBRARIES ${VTKm_LIBRARIES} ${VTKm_FCC_ADD_LIBRARIES})
if(${VTKm_FCC_IS_BACKEND})
set(VTKm_BACKEND_INCLUDE_DIRS ${VTKm_BACKEND_INCLUDE_DIRS} ${VTKm_FCC_ADD_INCLUDES})
set(VTKm_BACKEND_LIBRARIES ${VTKm_BACKEND_LIBRARIES} ${VTKm_FCC_ADD_LIBRARIES})
endif()
endif()
endif()
endmacro()
@ -118,6 +122,7 @@ macro(vtkm_configure_component_Serial)
vtkm_configure_component_Base()
vtkm_finish_configure_component(Serial
IS_BACKEND
DEPENDENT_VARIABLES VTKm_Base_FOUND
)
endmacro(vtkm_configure_component_Serial)
@ -151,8 +156,10 @@ macro(vtkm_configure_component_OpenGL)
find_package(GLEW ${VTKm_FIND_PACKAGE_QUIETLY})
list(APPEND vtkm_opengl_dependent_vars GLEW_FOUND)
list(APPEND vtkm_opengl_includes ${GLEW_INCLUDE_DIRS})
list(APPEND vtkm_opengl_libraries ${GLEW_LIBRARIES})
if(GLEW_FOUND)
list(APPEND vtkm_opengl_includes ${GLEW_INCLUDE_DIRS})
list(APPEND vtkm_opengl_libraries ${GLEW_LIBRARIES})
endif()
#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(UNIX)
@ -166,6 +173,10 @@ macro(vtkm_configure_component_OpenGL)
ADD_INCLUDES ${vtkm_opengl_includes}
ADD_LIBRARIES ${vtkm_opengl_libraries}
)
set(VTKm_OPENGL_INCLUDE_DIRS ${vtkm_opengl_includes})
set(VTKm_OPENGL_LIBRARIES ${vtkm_opengl_libraries})
endmacro(vtkm_configure_component_OpenGL)
macro(vtkm_configure_component_OSMesa)
@ -189,8 +200,8 @@ macro(vtkm_configure_component_EGL)
vtkm_finish_configure_component(EGL
DEPENDENT_VARIABLES VTKm_OpenGL_FOUND EGL_FOUND
ADD_INCLUDES ${EGL_INCLUDE_DIR}
ADD_LIBRARIES ${EGL_LIBRARY}
ADD_INCLUDES ${EGL_INCLUDE_DIRS}
ADD_LIBRARIES ${EGL_LIBRARIES}
)
endmacro(vtkm_configure_component_EGL)
@ -201,8 +212,8 @@ macro(vtkm_configure_component_GLFW)
vtkm_finish_configure_component(GLFW
DEPENDENT_VARIABLES VTKm_OpenGL_FOUND GLFW_FOUND
ADD_INCLUDES ${GLFW_INCLUDE_DIR}
ADD_LIBRARIES ${GLFW_LIBRARY}
ADD_INCLUDES ${GLFW_INCLUDE_DIRS}
ADD_LIBRARIES ${GLFW_LIBRARIES}
)
endmacro(vtkm_configure_component_GLFW)
@ -247,6 +258,7 @@ macro(vtkm_configure_component_TBB)
endif()
vtkm_finish_configure_component(TBB
IS_BACKEND
DEPENDENT_VARIABLES VTKm_ENABLE_TBB VTKm_Base_FOUND TBB_FOUND
ADD_INCLUDES ${TBB_INCLUDE_DIRS}
ADD_LIBRARIES ${TBB_LIBRARIES}
@ -258,6 +270,10 @@ macro(vtkm_configure_component_CUDA)
vtkm_configure_component_Base()
find_package(CUDA ${VTKm_FIND_PACKAGE_QUIETLY})
#Make cuda link privately to cuda libraries
set(CUDA_LIBRARIES PRIVATE ${CUDA_LIBRARIES})
mark_as_advanced(
CUDA_BUILD_CUBIN
CUDA_BUILD_EMULATION
@ -272,6 +288,7 @@ macro(vtkm_configure_component_CUDA)
endif()
vtkm_finish_configure_component(CUDA
IS_BACKEND
DEPENDENT_VARIABLES
VTKm_ENABLE_CUDA
VTKm_Base_FOUND

54
CMake/VTKmMacros.cmake
View File

@ -109,16 +109,21 @@ function(vtkm_add_header_build_test name dir_prefix use_cuda)
# and we want system includes so we have to hijack cuda
# to do it
foreach(dir ${VTKm_INCLUDE_DIRS})
#this internal variable has changed names depending on the CMake ver
list(APPEND CUDA_NVCC_INCLUDE_ARGS_USER -isystem ${dir})
list(APPEND CUDA_NVCC_INCLUDE_DIRS_USER -isystem ${dir})
endforeach()
cuda_include_directories(${VTKm_SOURCE_DIR}
${VTKm_BINARY_DIR}/include
)
cuda_add_library(TestBuild_${name} STATIC ${cxxfiles} ${hfiles})
target_include_directories(TestBuild_${name} PRIVATE ${VTKm_INCLUDE_DIRS})
elseif (${cxxfiles_len} GREATER 0)
add_library(TestBuild_${name} STATIC ${cxxfiles} ${hfiles})
target_include_directories(TestBuild_${name} PRIVATE ${VTKm_INCLUDE_DIRS})
target_include_directories(TestBuild_${name} PRIVATE vtkm ${VTKm_INCLUDE_DIRS})
endif ()
target_link_libraries(TestBuild_${name} ${VTKm_LIBRARIES})
target_link_libraries(TestBuild_${name} PRIVATE vtkm_cont ${VTKm_LIBRARIES})
set_source_files_properties(${hfiles}
PROPERTIES HEADER_FILE_ONLY TRUE
)
@ -263,7 +268,10 @@ function(vtkm_unit_tests)
vtkm_setup_nvcc_flags( old_nvcc_flags old_cxx_flags )
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_include_directories(${VTKm_SOURCE_DIR}
${VTKm_BINARY_DIR}/include
${VTKm_INCLUDE_DIRS}
)
cuda_add_executable(${test_prog} ${TestSources})
@ -278,7 +286,7 @@ function(vtkm_unit_tests)
#for any other targets
target_include_directories(${test_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${test_prog} ${VTKm_LIBRARIES})
target_link_libraries(${test_prog} PRIVATE vtkm_cont ${VTKm_LIBRARIES})
target_compile_options(${test_prog} PRIVATE ${VTKm_COMPILE_OPTIONS})
@ -395,7 +403,10 @@ function(vtkm_worklet_unit_tests device_adapter)
vtkm_setup_nvcc_flags( old_nvcc_flags old_cxx_flags )
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_include_directories(${VTKm_SOURCE_DIR}
${VTKm_BINARY_DIR}/include
${VTKm_INCLUDE_DIRS}
)
cuda_add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
@ -405,7 +416,7 @@ function(vtkm_worklet_unit_tests device_adapter)
add_executable(${test_prog} ${unit_test_drivers} ${unit_test_srcs})
endif()
target_include_directories(${test_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${test_prog} ${VTKm_LIBRARIES})
target_link_libraries(${test_prog} PRIVATE vtkm_cont ${VTKm_LIBRARIES})
#add the specific compile options for this executable
target_compile_options(${test_prog} PRIVATE ${VTKm_COMPILE_OPTIONS})
@ -522,7 +533,11 @@ function(vtkm_benchmarks device_adapter)
if(is_cuda)
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_include_directories(${VTKm_SOURCE_DIR}
${VTKm_BINARY_DIR}/include
${VTKm_BACKEND_INCLUDE_DIRS}
)
cuda_add_executable(${benchmark_prog} ${file} ${benchmark_headers})
else()
@ -532,8 +547,8 @@ function(vtkm_benchmarks device_adapter)
set_source_files_properties(${benchmark_headers}
PROPERTIES HEADER_FILE_ONLY TRUE)
target_include_directories(${benchmark_prog} PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(${benchmark_prog} ${VTKm_LIBRARIES})
target_include_directories(${benchmark_prog} PRIVATE ${VTKm_BACKEND_INCLUDE_DIRS})
target_link_libraries(${benchmark_prog} PRIVATE vtkm_cont ${VTKm_BACKEND_LIBRARIES})
if(MSVC)
vtkm_setup_msvc_properties(${benchmark_prog})
@ -610,7 +625,10 @@ function(vtkm_library)
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_include_directories(${VTKm_SOURCE_DIR}
${VTKm_BINARY_DIR}/include
${VTKm_BACKEND_INCLUDE_DIRS}
)
if(BUILD_SHARED_LIBS AND NOT WIN32)
set(compile_options -Xcompiler=${CMAKE_CXX_COMPILE_OPTIONS_VISIBILITY}hidden)
@ -625,18 +643,8 @@ function(vtkm_library)
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} )
set(lib_subset)
foreach(lib ${VTKm_LIBRARIES})
if(NOT lib STREQUAL lib_name)
list(APPEND lib_subset ${lib})
endif()
endforeach()
target_link_libraries(${lib_name} ${lib_subset})
#need to link to the vtkm target as makes C++11 become enabled
target_link_libraries(${lib_name} PUBLIC vtkm)
set(cxx_args ${VTKm_COMPILE_OPTIONS})
separate_arguments(cxx_args)

10
CMakeLists.txt
View File

@ -50,11 +50,6 @@ determine_version(${VTKm_SOURCE_DIR} ${GIT_EXECUTABLE} "VTKm")
# include some vtkm-specific cmake code.
include(VTKmMacros)
set(VTKm_INCLUDE_DIRS
${CMAKE_CURRENT_BINARY_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}
)
# Create an "interface" target library. This is not a real library but rather
# holds CMake configuration that is required for CXX targets that use VTK-m
# headers. In particular, it makes sure the appropriate C++11 version is being
@ -64,6 +59,11 @@ set(VTKm_INCLUDE_DIRS
# configuration.
add_library(vtkm INTERFACE)
target_compile_features(vtkm INTERFACE cxx_auto_type)
target_include_directories(vtkm INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
$<INSTALL_INTERFACE:include>
)
install(TARGETS vtkm EXPORT ${VTKm_EXPORT_NAME})
# Load the base VTK-m configuration, which is required for some of the later

3
data/tornado.vec Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:dca8105bf888e67a9fe476a563d69ac708925aec519814fb520c6057e5ca0a1f
size 1327116

6
examples/clipping/CMakeLists.txt
View File

@ -26,7 +26,7 @@ find_package(VTKm REQUIRED QUIET
add_executable(Clipping_SERIAL Clipping.cxx)
target_include_directories(Clipping_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Clipping_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(Clipping_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(Clipping_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
target_compile_definitions(Clipping_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
@ -45,7 +45,7 @@ if(VTKm_CUDA_FOUND)
cuda_add_executable(Clipping_CUDA ${cudaSource})
target_include_directories(Clipping_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Clipping_CUDA ${VTKm_LIBRARIES})
target_link_libraries(Clipping_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(Clipping_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
@ -56,7 +56,7 @@ endif()
if(VTKm_TBB_FOUND)
add_executable(Clipping_TBB Clipping.cxx)
target_include_directories(Clipping_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Clipping_TBB ${VTKm_LIBRARIES})
target_link_libraries(Clipping_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(Clipping_TBB PRIVATE PRIVATE ${VTKm_COMPILE_OPTIONS})
target_compile_definitions(Clipping_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")

12
examples/contour_tree/CMakeLists.txt
View File

@ -27,12 +27,12 @@ find_package(VTKm REQUIRED QUIET
add_executable(ContourTreeMesh2D_SERIAL ContourTreeMesh2D.cxx)
target_include_directories(ContourTreeMesh2D_SERIAL PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh2D_SERIAL ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh2D_SERIAL ${GLUT_LIBRARIES} PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh2D_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(ContourTreeMesh3D_SERIAL ContourTreeMesh3D.cxx)
target_include_directories(ContourTreeMesh3D_SERIAL PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh3D_SERIAL ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh3D_SERIAL ${GLUT_LIBRARIES} PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh3D_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
if(VTKm_CUDA_FOUND)
@ -48,14 +48,14 @@ if(VTKm_CUDA_FOUND)
configure_file(ContourTreeMesh2D.cxx ${cudaSource} COPYONLY)
cuda_add_executable(ContourTreeMesh2D_CUDA ${cudaSource})
target_include_directories(ContourTreeMesh2D_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh2D_CUDA ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh2D_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh2D_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
set (cudaSource "${CMAKE_CURRENT_BINARY_DIR}/ContourTreeMesh3D.cu")
configure_file(ContourTreeMesh3D.cxx ${cudaSource} COPYONLY)
cuda_add_executable(ContourTreeMesh3D_CUDA ${cudaSource})
target_include_directories(ContourTreeMesh3D_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh3D_CUDA ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh3D_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh3D_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
@ -65,11 +65,11 @@ endif()
if(VTKm_TBB_FOUND)
add_executable(ContourTreeMesh2D_TBB ContourTreeMesh2D.cxx)
target_include_directories(ContourTreeMesh2D_TBB PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh2D_TBB ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh2D_TBB ${GLUT_LIBRARIES} PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh2D_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(ContourTreeMesh3D_TBB ContourTreeMesh3D.cxx)
target_include_directories(ContourTreeMesh3D_TBB PRIVATE ${GLUT_INCLUDE_DIR} ${VTKm_INCLUDE_DIRS})
target_link_libraries(ContourTreeMesh3D_TBB ${GLUT_LIBRARIES} ${VTKm_LIBRARIES})
target_link_libraries(ContourTreeMesh3D_TBB ${GLUT_LIBRARIES} PRIVATE ${VTKm_LIBRARIES})
target_compile_options(ContourTreeMesh3D_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

2
examples/demo/CMakeLists.txt
View File

@ -38,7 +38,7 @@ if(VTKm_OSMesa_FOUND AND VTKm_Rendering_FOUND)
#need to setup the default device adapter.
target_include_directories(Demo PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Demo ${VTKm_LIBRARIES})
target_link_libraries(Demo PRIVATE ${VTKm_LIBRARIES})
target_compile_options(Demo PRIVATE ${VTKm_COMPILE_OPTIONS})
#when we are using TBB pass in the default device adapter as

2
examples/dynamic_dispatcher/CMakeLists.txt
View File

@ -23,5 +23,5 @@
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_link_libraries(DynamicDispatcherExample PRIVATE ${VTKm_LIBRARIES})
target_compile_options(DynamicDispatcherExample PRIVATE ${VTKm_COMPILE_OPTIONS})

6
examples/hello_world/CMakeLists.txt
View File

@ -30,7 +30,7 @@ if(VTKm_Interop_FOUND AND VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
add_executable(HelloWorld_SERIAL HelloWorld.cxx LoadShaders.h)
set_source_files_properties(LoadShaders.h PROPERTIES HEADER_FILE_ONLY TRUE)
target_include_directories(HelloWorld_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(HelloWorld_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(HelloWorld_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(HelloWorld_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
if(VTKm_CUDA_FOUND)
@ -39,14 +39,14 @@ if(VTKm_Interop_FOUND AND VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
vtkm_disable_troublesome_thrust_warnings()
cuda_add_executable(HelloWorld_CUDA HelloWorld.cu LoadShaders.h)
target_include_directories(HelloWorld_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(HelloWorld_CUDA ${VTKm_LIBRARIES})
target_link_libraries(HelloWorld_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(HelloWorld_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()
if(VTKm_TBB_FOUND)
add_executable(HelloWorld_TBB HelloWorldTBB.cxx LoadShaders.h)
target_include_directories(HelloWorld_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(HelloWorld_TBB ${VTKm_LIBRARIES})
target_link_libraries(HelloWorld_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(HelloWorld_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

6
examples/isosurface/CMakeLists.txt
View File

@ -29,7 +29,7 @@ if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
add_executable(IsosurfaceUniformGrid_SERIAL IsosurfaceUniformGrid.cxx quaternion.h)
set_source_files_properties(quaternion.h PROPERTIES HEADER_FILE_ONLY TRUE)
target_include_directories(IsosurfaceUniformGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(IsosurfaceUniformGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(IsosurfaceUniformGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(IsosurfaceUniformGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
if(VTKm_CUDA_FOUND)
@ -37,14 +37,14 @@ if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_add_executable(IsosurfaceUniformGrid_CUDA IsosurfaceUniformGrid.cu quaternion.h)
target_link_libraries(IsosurfaceUniformGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(IsosurfaceUniformGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(IsosurfaceUniformGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()
if(VTKm_ENABLE_TBB)
add_executable(IsosurfaceUniformGrid_TBB IsosurfaceUniformGridTBB.cxx quaternion.h)
target_include_directories(IsosurfaceUniformGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(IsosurfaceUniformGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(IsosurfaceUniformGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(IsosurfaceUniformGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

10
examples/multi_backend/CMakeLists.txt
View File

@ -26,13 +26,21 @@ find_package(VTKm REQUIRED QUIET
)
if(VTKm_CUDA_FOUND)
set(old_nvcc_flags ${CUDA_NVCC_FLAGS})
set(old_cxx_flags ${CMAKE_CXX_FLAGS})
vtkm_setup_nvcc_flags( old_nvcc_flags old_cxx_flags)
vtkm_disable_troublesome_thrust_warnings()
# Cuda compiles do not respect target_include_directories
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_add_executable(MultiBackend MultiBackend.cu)
set(CUDA_NVCC_FLAGS ${old_nvcc_flags})
set(CMAKE_CXX_FLAGS ${old_cxx_flags})
else()
add_executable(MultiBackend MultiBackend.cxx)
endif()
target_include_directories(MultiBackend PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(MultiBackend ${VTKm_LIBRARIES})
target_link_libraries(MultiBackend PRIVATE ${VTKm_LIBRARIES})
target_compile_options(MultiBackend PRIVATE ${VTKm_COMPILE_OPTIONS})

2
examples/rendering/CMakeLists.txt
View File

@ -28,6 +28,6 @@ find_package(VTKm REQUIRED QUIET
if(VTKm_OpenGL_FOUND AND VTKm_Rendering_FOUND AND VTKm_GLUT_FOUND)
add_executable(Rendering_SERIAL Rendering.cxx)
target_include_directories(Rendering_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(Rendering_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(Rendering_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(Rendering_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

6
examples/streamline/CMakeLists.txt
View File

@ -28,7 +28,7 @@ find_package(VTKm REQUIRED QUIET
if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
add_executable(StreamLineUniformGrid_SERIAL StreamLineUniformGrid.cxx)
target_include_directories(StreamLineUniformGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(StreamLineUniformGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(StreamLineUniformGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(StreamLineUniformGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
if(VTKm_CUDA_FOUND)
@ -36,14 +36,14 @@ if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
cuda_include_directories(${VTKm_INCLUDE_DIRS})
cuda_add_executable(StreamLineUniformGrid_CUDA StreamLineUniformGrid.cu)
target_include_directories(StreamLineUniformGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(StreamLineUniformGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(StreamLineUniformGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(StreamLineUniformGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()
if(VTKm_TBB_FOUND)
add_executable(StreamLineUniformGrid_TBB StreamLineUniformGridTBB.cxx)
target_include_directories(StreamLineUniformGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(StreamLineUniformGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(StreamLineUniformGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(StreamLineUniformGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

24
examples/tetrahedra/CMakeLists.txt
View File

@ -29,22 +29,22 @@ find_package(VTKm REQUIRED QUIET
if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
add_executable(TetrahedralizeExplicitGrid_SERIAL TetrahedralizeExplicitGrid.cxx)
target_include_directories(TetrahedralizeExplicitGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeExplicitGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeExplicitGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeExplicitGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TriangulateExplicitGrid_SERIAL TriangulateExplicitGrid.cxx)
target_include_directories(TriangulateExplicitGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateExplicitGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(TriangulateExplicitGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateExplicitGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TetrahedralizeUniformGrid_SERIAL TetrahedralizeUniformGrid.cxx)
target_include_directories(TetrahedralizeUniformGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeUniformGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeUniformGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeUniformGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TriangulateUniformGrid_SERIAL TriangulateUniformGrid.cxx)
target_include_directories(TriangulateUniformGrid_SERIAL PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateUniformGrid_SERIAL ${VTKm_LIBRARIES})
target_link_libraries(TriangulateUniformGrid_SERIAL PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateUniformGrid_SERIAL PRIVATE ${VTKm_COMPILE_OPTIONS})
if(VTKm_CUDA_FOUND)
@ -53,44 +53,44 @@ if(VTKm_OpenGL_FOUND AND VTKm_GLUT_FOUND)
cuda_add_executable(TetrahedralizeExplicitGrid_CUDA TetrahedralizeExplicitGrid.cu)
target_include_directories(TetrahedralizeExplicitGrid_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeExplicitGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeExplicitGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeExplicitGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
cuda_add_executable(TriangulateExplicitGrid_CUDA TriangulateExplicitGrid.cu)
target_include_directories(TriangulateExplicitGrid_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateExplicitGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(TriangulateExplicitGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateExplicitGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
cuda_add_executable(TetrahedralizeUniformGrid_CUDA TetrahedralizeUniformGrid.cu)
target_include_directories(TetrahedralizeUniformGrid_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeUniformGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeUniformGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeUniformGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
cuda_add_executable(TriangulateUniformGrid_CUDA TriangulateUniformGrid.cu)
target_include_directories(TriangulateUniformGrid_CUDA PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateUniformGrid_CUDA ${VTKm_LIBRARIES})
target_link_libraries(TriangulateUniformGrid_CUDA PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateUniformGrid_CUDA PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()
if(VTKm_ENABLE_TBB)
add_executable(TetrahedralizeExplicitGrid_TBB TetrahedralizeExplicitGridTBB.cxx)
target_include_directories(TetrahedralizeExplicitGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeExplicitGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeExplicitGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeExplicitGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TriangulateExplicitGrid_TBB TriangulateExplicitGridTBB.cxx)
target_include_directories(TriangulateExplicitGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateExplicitGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(TriangulateExplicitGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateExplicitGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TetrahedralizeUniformGrid_TBB TetrahedralizeUniformGridTBB.cxx)
target_include_directories(TetrahedralizeUniformGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TetrahedralizeUniformGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(TetrahedralizeUniformGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TetrahedralizeUniformGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
add_executable(TriangulateUniformGrid_TBB TriangulateUniformGridTBB.cxx)
target_include_directories(TriangulateUniformGrid_TBB PRIVATE ${VTKm_INCLUDE_DIRS})
target_link_libraries(TriangulateUniformGrid_TBB ${VTKm_LIBRARIES})
target_link_libraries(TriangulateUniformGrid_TBB PRIVATE ${VTKm_LIBRARIES})
target_compile_options(TriangulateUniformGrid_TBB PRIVATE ${VTKm_COMPILE_OPTIONS})
endif()

8
vtkm/cont/ArrayHandle.h
View File

@ -26,8 +26,8 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorControlInternal.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/StorageBasic.h>
@ -338,8 +338,8 @@ public:
///
/// The allocation may be done on an already existing array, but can wipe out
/// any data already in the array. This method can throw
/// ErrorControlBadAllocation if the array cannot be allocated or
/// ErrorControlBadValue if the allocation is not feasible (for example, the
/// ErrorBadAllocation if the array cannot be allocated or
/// ErrorBadValue if the allocation is not feasible (for example, the
/// array storage is read-only).
///
VTKM_CONT

16
vtkm/cont/ArrayHandle.hxx
View File

@ -32,7 +32,7 @@ ArrayHandle<T,S>::GetStorage()
}
else
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
@ -48,7 +48,7 @@ ArrayHandle<T,S>::GetStorage() const
}
else
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
@ -68,7 +68,7 @@ ArrayHandle<T,S>::GetPortalControl()
}
else
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
@ -84,7 +84,7 @@ ArrayHandle<T,S>::GetPortalConstControl() const
}
else
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandle::SyncControlArray did not make control array valid.");
}
}
@ -121,7 +121,7 @@ void ArrayHandle<T,S>::CopyInto(IteratorType dest, DeviceAdapterTag) const
if (!this->Internals->ControlArrayValid &&
!this->Internals->ExecutionArrayValid)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandle has no data to copy into Iterator.");
}
@ -170,7 +170,7 @@ void ArrayHandle<T,S>::Shrink(vtkm::Id numberOfValues)
}
else // numberOfValues > originalNumberOfValues
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandle::Shrink cannot be used to grow array.");
}
@ -187,7 +187,7 @@ ArrayHandle<T,S>::PrepareForInput(DeviceAdapterTag) const
if (!this->Internals->ControlArrayValid
&& !this->Internals->ExecutionArrayValid)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandle has no data when PrepareForInput called.");
}
@ -242,7 +242,7 @@ ArrayHandle<T,S>::PrepareForInPlace(DeviceAdapterTag)
if (!this->Internals->ControlArrayValid
&& !this->Internals->ExecutionArrayValid)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandle has no data when PrepareForInPlace called.");
}

12
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -23,7 +23,7 @@
#include <vtkm/Assert.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
namespace vtkm {
namespace exec {
@ -229,13 +229,13 @@ public:
VTKM_CONT
void Allocate(vtkm::Id /*numberOfValues*/)
{
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
throw vtkm::cont::ErrorBadAllocation("Does not make sense.");
}
VTKM_CONT
void Shrink(vtkm::Id /*numberOfValues*/)
{
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
throw vtkm::cont::ErrorBadAllocation("Does not make sense.");
}
VTKM_CONT
@ -327,7 +327,7 @@ public:
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
{
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Cannot write to an ArrayHandleCartesianProduct. It does not make "
"sense because there is overlap in the data.");
}
@ -335,7 +335,7 @@ public:
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Cannot write to an ArrayHandleCartesianProduct. It does not make "
"sense because there is overlap in the data.");
}
@ -351,7 +351,7 @@ public:
VTKM_CONT
void Shrink(vtkm::Id /*numberOfValues*/)
{
throw vtkm::cont::ErrorControlBadAllocation("Does not make sense.");
throw vtkm::cont::ErrorBadAllocation("Does not make sense.");
}
VTKM_CONT

35
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -21,8 +21,8 @@
#define vtk_m_ArrayHandleCompositeVector_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorControlInternal.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/StaticAssert.h>
#include <vtkm/VecTraits.h>
@ -158,7 +158,7 @@ struct CheckArraySizeFunctor {
message << "All input arrays to ArrayHandleCompositeVector must be the same size.\n"
<< "Array " << Index-1 << " has " << a.GetNumberOfValues()
<< ". Expected " << this->ExpectedSize << ".";
throw vtkm::cont::ErrorControlBadValue(message.str().c_str());
throw vtkm::cont::ErrorBadValue(message.str().c_str());
}
}
};
@ -213,6 +213,17 @@ public:
return localPortals.GetReturnValue();
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
void Set(vtkm::Id vtkmNotUsed(index),
const ValueType &vtkmNotUsed(value)) const
{
// There is no technical reason why this cannot be implemented. As of this
// writing no one has needed to write to a composite vector yet.
VTKM_ASSERT(false && "Set not yet implemented for composite vector. Do you volunteer to implement it?");
}
private:
PortalTypes Portals;
ComponentMapType SourceComponents;
@ -271,7 +282,7 @@ public:
VTKM_CONT
PortalType GetPortal() {
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays are read only.");
}
@ -279,7 +290,7 @@ public:
PortalConstType GetPortalConst() const {
if (!this->Valid)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Tried to use an ArrayHandleCompositeHandle without dependent arrays.");
}
return PortalConstType(this->Arrays.StaticTransformCont(
@ -291,7 +302,7 @@ public:
vtkm::Id GetNumberOfValues() const {
if (!this->Valid)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Tried to use an ArrayHandleCompositeHandle without dependent arrays.");
}
return this->Arrays.template GetParameter<1>().GetNumberOfValues();
@ -299,7 +310,7 @@ public:
VTKM_CONT
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"The allocate method for the composite vector storage should never "
"have been called. The allocate is generally only called by the "
@ -310,7 +321,7 @@ public:
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays are read-only.");
}
@ -392,7 +403,7 @@ public:
{
// It may be the case a composite vector could be used for in place
// operations, but this is not implemented currently.
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays cannot be used for output or in place.");
}
@ -402,21 +413,21 @@ public:
// It may be the case a composite vector could be used for output if you
// want the delegate arrays to be resized, but this is not implemented
// currently.
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays cannot be used for output.");
}
VTKM_CONT
void RetrieveOutputData(StorageType *vtkmNotUsed(storage)) const
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays cannot be used for output.");
}
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Composite vector arrays cannot be resized.");
}

4
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -143,7 +143,7 @@ public:
VTKM_CONT
void Allocate( vtkm::Id vtkmNotUsed(numberOfValues) )
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandleConcatenate should not be allocated explicitly. " );
}
@ -241,7 +241,7 @@ public:
VTKM_CONT
PortalExecution PrepareForOutput( vtkm::Id vtkmNotUsed(numberOfValues) )
{
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandleConcatenate is derived and read-only. " );
}

7
vtkm/cont/ArrayHandleCounting.h
View File

@ -82,6 +82,13 @@ public:
this->Step*ValueType(static_cast<ComponentType>(index)));
}
VTKM_EXEC_CONT
void Set(vtkm::Id vtkmNotUsed(index),
const ValueType &vtkmNotUsed(value)) const
{
VTKM_ASSERT(false && "Cannot write to read-only counting array.");
}
private:
ValueType Start;
ValueType Step;

246
vtkm/cont/ArrayHandleDiscard.h Normal file
View File

@ -0,0 +1,246 @@
//============================================================================
// 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 2017 Sandia Corporation.
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 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_ArrayHandleDiscard_h
#define vtk_m_cont_ArrayHandleDiscard_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/TypeTraits.h>
namespace vtkm {
namespace exec {
namespace internal {
/// \brief An output-only array portal with no storage. All written values are
/// discarded.
template <typename ValueType_>
class ArrayPortalDiscard
{
public:
using ValueType = ValueType_;
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
ArrayPortalDiscard()
: NumberOfValues(0)
{ } // needs to be host and device so that cuda can create lvalue of these
VTKM_CONT
explicit ArrayPortalDiscard(vtkm::Id numValues)
: NumberOfValues(numValues)
{ }
/// Copy constructor for any other ArrayPortalDiscard 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>
VTKM_CONT
ArrayPortalDiscard(const ArrayPortalDiscard<OtherV> &src)
: NumberOfValues(src.NumberOfValues)
{ }
VTKM_EXEC_CONT
vtkm::Id GetNumberOfValues() const
{
return this->NumberOfValues;
}
ValueType Get(vtkm::Id index) const {
VTKM_ASSERT(index < this->GetNumberOfValues());
VTKM_ASSERT("Method not supported for ArrayPortalDiscard." && false);
(void)index;
return vtkm::TypeTraits<ValueType>::ZeroInitialization();
}
VTKM_EXEC
void Set(vtkm::Id index, const ValueType &) const
{
VTKM_ASSERT(index < this->GetNumberOfValues());
(void)index;
// no-op
}
private:
vtkm::Id NumberOfValues;
};
} // end namespace internal
} // end namespace exec
namespace cont {
namespace internal {
struct VTKM_ALWAYS_EXPORT StorageTagDiscard { };
template <typename ValueType_>
class Storage<ValueType_, StorageTagDiscard>
{
public:
using ValueType = ValueType_;
using PortalType = vtkm::exec::internal::ArrayPortalDiscard<ValueType>;
using PortalConstType = vtkm::exec::internal::ArrayPortalDiscard<ValueType>;
VTKM_CONT
Storage() { }
VTKM_CONT
PortalType GetPortal()
{
return PortalType(this->NumberOfValues);
}
VTKM_CONT
PortalConstType GetPortalConst()
{
return PortalConstType(this->NumberOfValues);
}
VTKM_CONT
vtkm::Id GetNumberOfValues() const
{
return this->NumberOfValues;
}
VTKM_CONT
void Allocate(vtkm::Id numValues)
{
this->NumberOfValues = numValues;
}
VTKM_CONT
void Shrink(vtkm::Id numValues)
{
this->NumberOfValues = numValues;
}
VTKM_CONT
void ReleaseResources()
{
this->NumberOfValues = 0;
}
private:
vtkm::Id NumberOfValues;
};
template <typename ValueType_, typename DeviceAdapter_>
class ArrayTransfer<ValueType_, StorageTagDiscard, DeviceAdapter_>
{
using StorageTag = StorageTagDiscard;
using StorageType = Storage<ValueType_, StorageTag>;
public:
using ValueType = ValueType_;
using PortalControl = typename StorageType::PortalType;
using PortalConstControl = typename StorageType::PortalConstType;
using PortalExecution = vtkm::exec::internal::ArrayPortalDiscard<ValueType>;
using PortalConstExecution = vtkm::exec::internal::ArrayPortalDiscard<ValueType>;
VTKM_CONT
ArrayTransfer(StorageType *storage)
: Internal(storage)
{ }
VTKM_CONT
vtkm::Id GetNumberOfValues() const
{
VTKM_ASSERT(this->Internal != nullptr);
return this->Internal->GetNumberOfValues();
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
{
throw vtkm::cont::ErrorBadValue(
"Input access not supported: "
"Cannot read from an ArrayHandleDiscard.");
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
{
throw vtkm::cont::ErrorBadValue(
"InPlace access not supported: "
"Cannot read from an ArrayHandleDiscard.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numValues)
{
VTKM_ASSERT(this->Internal != nullptr);
this->Internal->Allocate(numValues);
return PortalConstExecution(this->Internal->GetNumberOfValues());
}
VTKM_CONT
void RetrieveOutputData(StorageType *storage) const
{
VTKM_ASSERT(storage == this->Internal);
(void)storage;
// no-op
}
VTKM_CONT
void Shrink(vtkm::Id numValues)
{
VTKM_ASSERT(this->Internal != nullptr);
this->Internal->Shrink(numValues);
}
VTKM_CONT
void ReleaseResources()
{
VTKM_ASSERT(this->Internal != nullptr);
this->Internal->ReleaseResources();
}
private:
StorageType *Internal;
};
template <typename ValueType_>
struct ArrayHandleDiscardTraits
{
using ValueType = ValueType_;
using StorageTag = StorageTagDiscard;
using Superclass = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
};
} // end namespace internal
/// ArrayHandleDiscard is a write-only array that discards all data written to
/// it. This can be used to save memory when a filter provides optional outputs
/// that are not needed.
template <typename ValueType_>
class ArrayHandleDiscard
: public internal::ArrayHandleDiscardTraits<ValueType_>::Superclass
{
public:
VTKM_ARRAY_HANDLE_SUBCLASS(
ArrayHandleDiscard,
(ArrayHandleDiscard<ValueType_>),
(typename internal::ArrayHandleDiscardTraits<ValueType_>::Superclass));
};
} // end namespace cont
} // end namespace vtkm
#endif // vtk_m_cont_ArrayHandleDiscard_h

10
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -22,7 +22,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayPortal.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
namespace vtkm {
namespace exec {
@ -164,7 +164,7 @@ public:
vtkm::Id sourceSize = this->SourceArray.GetNumberOfValues();
if(sourceSize%NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return sourceSize/NUM_COMPONENTS;
@ -247,7 +247,7 @@ public:
vtkm::Id sourceSize = this->SourceArray.GetNumberOfValues();
if (sourceSize%NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return sourceSize/NUM_COMPONENTS;
@ -258,7 +258,7 @@ public:
{
if (this->SourceArray.GetNumberOfValues()%NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return PortalConstExecution(this->SourceArray.PrepareForInput(Device()));
@ -269,7 +269,7 @@ public:
{
if (this->SourceArray.GetNumberOfValues()%NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return PortalExecution(this->SourceArray.PrepareForInPlace(Device()));

4
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -24,7 +24,7 @@
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/ArrayPortal.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/Assert.h>
@ -487,7 +487,7 @@ void DoConvertNumComponentsToOffsets(
if (!success)
{
// Internal error? Maybe need to make a failed to execute error.
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"Failed to run ExclusiveScan on any device.");
}

10
vtkm/cont/ArrayHandleImplicit.h
View File

@ -60,9 +60,19 @@ public:
VTKM_EXEC_CONT
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
ValueType Get(vtkm::Id index) const { return this->Functor(index); }
VTKM_EXEC_CONT
void Set(vtkm::Id vtkmNotUsed(index),
const ValueType &vtkmNotUsed(value)) const
{
#if !(defined(VTKM_MSVC) && defined(VTKM_CUDA))
VTKM_ASSERT(false && "Cannot write to read-only implicit array.");
#endif
}
typedef vtkm::cont::internal::IteratorFromArrayPortal<
ArrayPortalImplicit<ValueType,FunctorType> > IteratorType;

14
vtkm/cont/ArrayHandlePermutation.h
View File

@ -23,8 +23,8 @@
#define vtk_m_ArrayHandlePermutation_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/ErrorBadValue.h>
namespace vtkm {
namespace exec {
@ -153,13 +153,13 @@ public:
VTKM_CONT
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandlePermutation cannot be allocated.");
}
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandlePermutation cannot shrink.");
}
@ -234,7 +234,7 @@ public:
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
{
if (numberOfValues != this->GetNumberOfValues()) {
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"An ArrayHandlePermutation can be used as an output array, "
"but it cannot be resized. Make sure the index array is sized "
"to the appropriate length before trying to prepare for output.");
@ -246,7 +246,7 @@ public:
// we have to assume the allocation is correct.
if ((numberOfValues > 0) && (this->ValueArray.GetNumberOfValues() < 1))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"The value array must be pre-allocated before it is used for the "
"output of ArrayHandlePermutation.");
}
@ -265,7 +265,7 @@ public:
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandlePermutation cannot shrink.");
}

26
vtkm/cont/ArrayHandleTransform.h
View File

@ -23,8 +23,8 @@
#define vtk_m_cont_ArrayHandleTransform_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorControlInternal.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/ErrorInternal.h>
namespace vtkm {
namespace cont {
@ -88,6 +88,16 @@ public:
return this->Functor(this->Portal.Get(index));
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
void Set(vtkm::Id vtkmNotUsed(index),
const ValueType &vtkmNotUsed(value)) const
{
#if !(defined(VTKM_MSVC) && defined(VTKM_CUDA))
VTKM_ASSERT(false && "Cannot write to read-only transform array. (No inverse transform given.)");
#endif
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
const PortalType &GetPortal() const { return this->Portal; }
@ -205,13 +215,13 @@ public:
VTKM_CONT
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleTransform is read only. It cannot be allocated.");
}
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleTransform is read only. It cannot shrink.");
}
@ -364,20 +374,20 @@ public:
VTKM_CONT
PortalExecution PrepareForInPlace(bool &vtkmNotUsed(updateData)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleTransform read only. "
"Cannot be used for in-place operations.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleTransform read only. Cannot be used as output.");
}
VTKM_CONT
void RetrieveOutputData(StorageType *vtkmNotUsed(storage)) const {
throw vtkm::cont::ErrorControlInternal(
throw vtkm::cont::ErrorInternal(
"ArrayHandleTransform read only. "
"There should be no occurance of the ArrayHandle trying to pull "
"data from the execution environment.");
@ -385,7 +395,7 @@ public:
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleTransform read only. Cannot shrink.");
}

5
vtkm/cont/ArrayPortal.h
View File

@ -72,8 +72,9 @@ public:
VTKM_CONT
ValueType Get(vtkm::Id index) const;
/// Sets a value in the array. This function may not exist for an ArrayPortal
/// pointing to a const array.
/// Sets a value in the array. If it is not possible to set a value in the
/// array, this method may error out (for example with a VTKM_ASSERT). In
/// this case the behavior is undefined.
///
VTKM_CONT
void Set(vtkm::Id index, const ValueType &value) const;

132
vtkm/cont/ArrayRangeCompute.h Normal file
View File

@ -0,0 +1,132 @@
//============================================================================
// 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_ArrayRangeCompute_h
#define vtk_m_cont_ArrayRangeCompute_h
#include <vtkm/Range.h>
#include <vtkm/VecTraits.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
namespace vtkm {
namespace cont {
namespace internal {
struct RangeMin
{
template<typename T>
VTKM_EXEC
T operator()(const T& a, const T& b)const { return vtkm::Min(a,b); }
};
struct RangeMax
{
template<typename T>
VTKM_EXEC
T operator()(const T& a, const T& b)const { return vtkm::Max(a,b); }
};
} // namespace internal
/// \brief Compute the range of the data in an array handle.
///
/// Given an \c ArrayHandle, this function computes the range (min and max) of
/// the values in the array. For arrays containing Vec values, the range is
/// computed for each component.
///
/// This method also takes a device adapter tag to specify the device on which
/// to compute the range.
///
/// The result is returned in an \c ArrayHandle of \c Range objects. There is
/// one value in the returned array for every component of the input's value
/// type.
///
template<typename ArrayHandleType, typename Device>
inline
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const ArrayHandleType &input, Device)
{
VTKM_IS_ARRAY_HANDLE(ArrayHandleType);
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
typedef typename ArrayHandleType::ValueType ValueType;
typedef vtkm::VecTraits<ValueType> VecType;
const vtkm::IdComponent NumberOfComponents = VecType::NUM_COMPONENTS;
typedef vtkm::cont::DeviceAdapterAlgorithm<Device> Algorithm;
//not the greatest way of doing this for performance reasons. But
//this implementation should generate the smallest amount of code
ValueType initialMin = input.GetPortalConstControl().Get(0);
ValueType initialMax = initialMin;
ValueType minResult =
Algorithm::Reduce(input, initialMin, internal::RangeMin());
ValueType maxResult =
Algorithm::Reduce(input, initialMax, internal::RangeMax());
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(NumberOfComponents);
for (vtkm::IdComponent i = 0; i < NumberOfComponents; ++i)
{
rangeArray.GetPortalControl().Set(
i, vtkm::Range(VecType::GetComponent(minResult, i),
VecType::GetComponent(maxResult, i)));
}
return rangeArray;
}
// Special implementation for regular point coordinates, which are easy
// to determine.
inline
vtkm::cont::ArrayHandle<vtkm::Range>
ArrayRangeCompute(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
&array)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal =
rangeArray.GetPortalControl();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));
return rangeArray;
}
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ArrayRangeCompute_h

12
vtkm/cont/CMakeLists.txt
View File

@ -25,6 +25,7 @@ set(headers
ArrayHandleCompositeVector.h
ArrayHandleConstant.h
ArrayHandleCounting.h
ArrayHandleDiscard.h
ArrayHandleGroupVec.h
ArrayHandleGroupVecVariable.h
ArrayHandleImplicit.h
@ -37,6 +38,7 @@ set(headers
ArrayPortal.h
ArrayPortalToIterators.h
ArrayHandleConcatenate.h
ArrayRangeCompute.h
CellSet.h
CellSetExplicit.h
CellSetListTag.h
@ -55,12 +57,11 @@ set(headers
DynamicArrayHandle.h
DynamicCellSet.h
Error.h
ErrorControl.h
ErrorControlBadAllocation.h
ErrorControlBadType.h
ErrorControlBadValue.h
ErrorControlInternal.h
ErrorBadAllocation.h
ErrorBadType.h
ErrorBadValue.h
ErrorExecution.h
ErrorInternal.h
Field.h
RuntimeDeviceInformation.h
Storage.h
@ -89,6 +90,7 @@ set(sources
)
vtkm_library(SOURCES ${sources})
target_include_directories(vtkm_cont PRIVATE ${VTKm_BACKEND_INCLUDE_DIRS})
#-----------------------------------------------------------------------------
add_subdirectory(internal)

10
vtkm/cont/CellSetExplicit.h
View File

@ -214,19 +214,19 @@ public:
if (Traits::GetNumberOfComponents(ids) < numVertices)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Not enough indices given to CellSetSingleType::AddCell.");
}
if (this->NumberOfCellsAdded >= this->PointToCell.Shapes.GetNumberOfValues())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Added more cells then expected.");
}
if (this->ConnectivityAdded+numVertices >
this->PointToCell.Connectivity.GetNumberOfValues())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Connectivity increased passed estimated maximum connectivity.");
}
@ -253,7 +253,7 @@ public:
if (this->NumberOfCellsAdded != this->GetNumberOfCells())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Did not add as many cells as expected.");
}
@ -289,7 +289,7 @@ public:
this->PointToCell.IndexOffsetsValid = false;
if (offsets.GetNumberOfValues() != 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Explicit cell offsets array unexpected size. "
"Use an empty array to automatically generate.");
}

16
vtkm/cont/CellSetSingleType.h
View File

@ -110,14 +110,14 @@ public:
if (Traits::GetNumberOfComponents(ids) < numVertices)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Not enough indices given to CellSetSingleType::AddCell.");
}
if (this->ConnectivityAdded+numVertices >
this->PointToCell.Connectivity.GetNumberOfValues())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Connectivity increased passed estimated maximum connectivity.");
}
@ -125,7 +125,7 @@ public:
{
if (shapeId == vtkm::CELL_SHAPE_EMPTY)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Cannot create cells of type empty.");
}
this->CellShapeAsId = shapeId;
@ -136,12 +136,12 @@ public:
{
if (shapeId != this->GetCellShape(0))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Cannot have differing shapes in CellSetSingleType.");
}
if (numVertices != this->NumberOfPointsPerCell)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Inconsistent number of points in cells for CellSetSingleType.");
}
}
@ -179,7 +179,7 @@ public:
if (this->ExpectedNumberOfCellsAdded != this->GetNumberOfCells())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Did not add the expected number of cells.");
}
@ -246,7 +246,7 @@ private:
{
if (numVertices != vtkm::CellTraits<CellShapeTag>::NUM_POINTS)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Passed invalid number of points for cell shape.");
}
}
@ -271,7 +271,7 @@ private:
vtkm::CellTraits<CellShapeTag>::IsSizeFixed(),
numVertices) );
default:
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"CellSetSingleType unable to determine the cell type");
}
}

20
vtkm/cont/DataSet.h
View File

@ -25,7 +25,7 @@
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Field.h>
namespace vtkm {
@ -86,7 +86,7 @@ public:
}
else
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"No field with requested name: " + name);
}
}
@ -99,6 +99,18 @@ public:
return this->GetField(this->GetFieldIndex(name, assoc));
}
VTKM_CONT
const vtkm::cont::Field &GetCellField(const std::string &name) const
{
return this->GetField(name, vtkm::cont::Field::ASSOC_CELL_SET);
}
VTKM_CONT
const vtkm::cont::Field &GetPointField(const std::string &name) const
{
return this->GetField(name, vtkm::cont::Field::ASSOC_POINTS);
}
VTKM_CONT
void AddCoordinateSystem(vtkm::cont::CoordinateSystem cs)
{
@ -133,7 +145,7 @@ public:
}
else
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"No coordinate system with requested name");
}
}
@ -186,7 +198,7 @@ public:
}
else
{
throw vtkm::cont::ErrorControlBadValue("No cell set with requested name");
throw vtkm::cont::ErrorBadValue("No cell set with requested name");
}
}

2
vtkm/cont/DataSetBuilderRectilinear.h
View File

@ -280,7 +280,7 @@ private:
dataSet.AddCellSet(cellSet);
}
else
throw vtkm::cont::ErrorControlBadValue("Invalid cell set dimension");
throw vtkm::cont::ErrorBadValue("Invalid cell set dimension");
return dataSet;
}

2
vtkm/cont/DataSetBuilderUniform.h
View File

@ -161,7 +161,7 @@ private:
dataSet.AddCellSet(cellSet);
}
else
throw vtkm::cont::ErrorControlBadValue("Invalid cell set dimension");
throw vtkm::cont::ErrorBadValue("Invalid cell set dimension");
return dataSet;
}

14
vtkm/cont/DynamicArrayHandle.h
View File

@ -26,7 +26,7 @@
#include <vtkm/VecTraits.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/StorageListTag.h>
#include <vtkm/cont/internal/DynamicTransform.h>
@ -260,7 +260,7 @@ public:
}
/// Returns this array cast to an ArrayHandle object of the given type and
/// storage. Throws \c ErrorControlBadType if the cast does not work. Use
/// storage. Throws \c ErrorBadType if the cast does not work. Use
/// \c IsTypeAndStorage to check if the cast can happen.
///
///
@ -272,7 +272,7 @@ public:
detail::DynamicArrayHandleTryCast<Type,Storage>(this->ArrayContainer);
if (downcastArray == nullptr)
{
throw vtkm::cont::ErrorControlBadType("Bad cast of dynamic array.");
throw vtkm::cont::ErrorBadType("Bad cast of dynamic array.");
}
// Technically, this method returns a copy of the \c ArrayHandle. But
// because \c ArrayHandle acts like a shared pointer, it is valid to
@ -281,7 +281,7 @@ public:
}
/// Returns this array cast to the given \c ArrayHandle type. Throws \c
/// ErrorControlBadType if the cast does not work. Use \c IsType
/// ErrorBadType if the cast does not work. Use \c IsType
/// to check if the cast can happen.
///
template<typename ArrayHandleType>
@ -298,7 +298,7 @@ public:
/// Given a refernce to an ArrayHandle object, casts this array to the
/// ArrayHandle's type and sets the given ArrayHandle to this array. Throws
/// \c ErrorControlBadType if the cast does not work. Use \c
/// \c ErrorBadType if the cast does not work. Use \c
/// ArrayHandleType to check if the cast can happen.
///
/// Note that this is a shallow copy. The data are not copied and a change
@ -514,7 +514,7 @@ void DynamicArrayHandleBase<TypeList,StorageList>::
vtkm::ListForEach(tryType, TypeList());
if (!tryType.FoundCast)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Could not find appropriate cast for array in CastAndCall1.");
}
}
@ -538,7 +538,7 @@ void DynamicArrayHandleBase<VTKM_DEFAULT_TYPE_LIST_TAG,
vtkm::ListForEach(tryType, VTKM_DEFAULT_TYPE_LIST_TAG());
if (!tryType.FoundCast)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Could not find appropriate cast for array in CastAndCall2.");
}
}

10
vtkm/cont/DynamicCellSet.h
View File

@ -22,7 +22,7 @@
#include <vtkm/cont/CellSet.h>
#include <vtkm/cont/CellSetListTag.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/internal/DynamicTransform.h>
#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
@ -183,7 +183,7 @@ public:
}
/// Returns this cell set cast to the given \c CellSet type. Throws \c
/// ErrorControlBadType if the cast does not work. Use \c IsType to check if
/// ErrorBadType if the cast does not work. Use \c IsType to check if
/// the cast can happen.
///
template<typename CellSetType>
@ -193,14 +193,14 @@ public:
detail::DynamicCellSetTryCast<CellSetType>(this->CellSetContainer);
if (cellSetPointer == nullptr)
{
throw vtkm::cont::ErrorControlBadType("Bad cast of dynamic cell set.");
throw vtkm::cont::ErrorBadType("Bad cast of dynamic cell set.");
}
return *cellSetPointer;
}
/// Given a reference to a concrete \c CellSet object, attempt to downcast
/// the contain cell set to the provided type and copy into the given \c
/// CellSet object. Throws \c ErrorControlBadType if the cast does not work.
/// CellSet object. Throws \c ErrorBadType if the cast does not work.
/// Use \c IsType to check if the cast can happen.
///
/// Note that this is a shallow copy. Any data in associated arrays are not
@ -344,7 +344,7 @@ void DynamicCellSetBase<CellSetList>::CastAndCall(const Functor &f) const
vtkm::ListForEach(tryCellSet, CellSetList());
if (!tryCellSet.FoundCast)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Could not find appropriate cast for cell set.");
}
}

14
vtkm/cont/ErrorControlBadAllocation.h → vtkm/cont/ErrorBadAllocation.h
View File

@ -17,10 +17,10 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ErrorControlBadAllocation_h
#define vtk_m_cont_ErrorControlBadAllocation_h
#ifndef vtk_m_cont_ErrorBadAllocation_h
#define vtk_m_cont_ErrorBadAllocation_h
#include <vtkm/cont/ErrorControl.h>
#include <vtkm/cont/Error.h>
namespace vtkm {
namespace cont {
@ -28,14 +28,14 @@ namespace cont {
/// This class is thrown when VTK-m attempts to manipulate memory that it should
/// not.
///
class VTKM_ALWAYS_EXPORT ErrorControlBadAllocation : public ErrorControl
class VTKM_ALWAYS_EXPORT ErrorBadAllocation : public Error
{
public:
ErrorControlBadAllocation(const std::string &message)
: ErrorControl(message) { }
ErrorBadAllocation(const std::string &message)
: Error(message) { }
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ErrorControlBadAllocation_h
#endif //vtk_m_cont_ErrorBadAllocation_h

14
vtkm/cont/ErrorControlBadType.h → vtkm/cont/ErrorBadType.h
View File

@ -17,10 +17,10 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ErrorControlBadType_h
#define vtk_m_cont_ErrorControlBadType_h
#ifndef vtk_m_cont_ErrorBadType_h
#define vtk_m_cont_ErrorBadType_h
#include <vtkm/cont/ErrorControl.h>
#include <vtkm/cont/Error.h>
namespace vtkm {
namespace cont {
@ -28,14 +28,14 @@ namespace cont {
/// This class is thrown when VTK-m encounters data of a type that is
/// incompatible with the current operation.
///
class VTKM_ALWAYS_EXPORT ErrorControlBadType : public ErrorControl
class VTKM_ALWAYS_EXPORT ErrorBadType : public Error
{
public:
ErrorControlBadType(const std::string &message)
: ErrorControl(message) { }
ErrorBadType(const std::string &message)
: Error(message) { }
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ErrorControlBadType_h
#endif //vtk_m_cont_ErrorBadType_h

14
vtkm/cont/ErrorControlBadValue.h → vtkm/cont/ErrorBadValue.h
View File

@ -17,10 +17,10 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ErrorControlBadValue_h
#define vtk_m_cont_ErrorControlBadValue_h
#ifndef vtk_m_cont_ErrorBadValue_h
#define vtk_m_cont_ErrorBadValue_h
#include <vtkm/cont/ErrorControl.h>
#include <vtkm/cont/Error.h>
namespace vtkm {
namespace cont {
@ -28,14 +28,14 @@ namespace cont {
/// This class is thrown when a VTKm function or method encounters an invalid
/// value that inhibits progress.
///
class VTKM_ALWAYS_EXPORT ErrorControlBadValue : public ErrorControl
class VTKM_ALWAYS_EXPORT ErrorBadValue : public Error
{
public:
ErrorControlBadValue(const std::string &message)
: ErrorControl(message) { }
ErrorBadValue(const std::string &message)
: Error(message) { }
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ErrorControlBadValue_h
#endif //vtk_m_cont_ErrorBadValue_h

41
vtkm/cont/ErrorControl.h
View File

@ -1,41 +0,0 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_cont_ErrorControl_h
#define vtk_m_cont_ErrorControl_h
#include <vtkm/cont/Error.h>
namespace vtkm {
namespace cont {
/// The superclass of all exceptions thrown from within the VTKm control
/// environment.
///
class VTKM_ALWAYS_EXPORT ErrorControl : public vtkm::cont::Error
{
protected:
ErrorControl() { }
ErrorControl(const std::string message) : Error(message) { }
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ErrorControl_h

14
vtkm/cont/ErrorControlInternal.h → vtkm/cont/ErrorInternal.h
View File

@ -17,10 +17,10 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ErrorControlInternal_h
#define vtk_m_cont_ErrorControlInternal_h
#ifndef vtk_m_cont_ErrorInternal_h
#define vtk_m_cont_ErrorInternal_h
#include <vtkm/cont/ErrorControl.h>
#include <vtkm/cont/Error.h>
namespace vtkm {
namespace cont {
@ -29,14 +29,14 @@ namespace cont {
/// be reached. This error usually indicates a bug in vtkm or, at best, VTKm
/// failed to detect an invalid input it should have.
///
class VTKM_ALWAYS_EXPORT ErrorControlInternal : public ErrorControl
class VTKM_ALWAYS_EXPORT ErrorInternal : public Error
{
public:
ErrorControlInternal(const std::string &message)
: ErrorControl(message) { }
ErrorInternal(const std::string &message)
: Error(message) { }
};
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ErrorControlInternal_h
#endif //vtk_m_cont_ErrorInternal_h

46
vtkm/cont/Field.h
View File

@ -31,6 +31,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ArrayRangeCompute.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicArrayHandle.h>
@ -50,50 +51,7 @@ public:
template<typename ArrayHandleType>
void operator()(const ArrayHandleType &input) const
{
typedef typename ArrayHandleType::ValueType ValueType;
typedef vtkm::VecTraits<ValueType> VecType;
const vtkm::IdComponent NumberOfComponents = VecType::NUM_COMPONENTS;
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag> Algorithm;
//not the greatest way of doing this for performance reasons. But
//this implementation should generate the smallest amount of code
vtkm::Vec<ValueType,2> initial(input.GetPortalConstControl().Get(0));
vtkm::Vec<ValueType, 2> result =
Algorithm::Reduce(input, initial, vtkm::MinAndMax<ValueType>());
this->Range->Allocate(NumberOfComponents);
for (vtkm::IdComponent i = 0; i < NumberOfComponents; ++i)
{
this->Range->GetPortalControl().Set(
i, vtkm::Range(VecType::GetComponent(result[0], i),
VecType::GetComponent(result[1], i)));
}
}
// Special implementation for regular point coordinates, which are easy
// to determine.
void operator()(const vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault,3>,
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>
&array)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal =
array.GetPortalConstControl();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
vtkm::Vec<vtkm::FloatDefault,3> minimum = portal.Get(0);
vtkm::Vec<vtkm::FloatDefault,3> maximum =
portal.Get(portal.GetNumberOfValues()-1);
this->Range->Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal =
this->Range->GetPortalControl();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));
*this->Range = vtkm::cont::ArrayRangeCompute(input, DeviceAdapterTag());
}
private:

4
vtkm/cont/Storage.h
View File

@ -132,8 +132,8 @@ public:
///
/// The allocation may be done on an already existing array, but can wipe out
/// any data already in the array. This method can throw
/// ErrorControlBadAllocation if the array cannot be allocated or
/// ErrorControlBadValue if the allocation is not feasible (for example, the
/// ErrorBadAllocation if the array cannot be allocated or
/// ErrorBadValue if the allocation is not feasible (for example, the
/// array storage is read-only).
///
VTKM_CONT

4
vtkm/cont/StorageBasic.h
View File

@ -22,8 +22,8 @@
#include <vtkm/Assert.h>
#include <vtkm/Types.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayPortalFromIterators.h>

10
vtkm/cont/StorageBasic.hxx
View File

@ -48,7 +48,7 @@ Storage<T, vtkm::cont::StorageTagBasic>::Storage(const Storage<T, StorageTagBasi
{
if (src.DeallocateOnRelease)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Attempted to copy a storage array that needs deallocation. "
"This is disallowed to prevent complications with deallocation.");
}
@ -60,7 +60,7 @@ Storage<T, vtkm::cont::StorageTagBasic>::operator=(const Storage<T, StorageTagBa
{
if (src.DeallocateOnRelease)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Attempted to copy a storage array that needs deallocation. "
"This is disallowed to prevent complications with deallocation.");
}
@ -108,7 +108,7 @@ void Storage<T, vtkm::cont::StorageTagBasic>::Allocate(vtkm::Id numberOfValues)
if(this->UserProvidedMemory)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"User allocated arrays cannot be reallocated.");
}
@ -134,7 +134,7 @@ void Storage<T, vtkm::cont::StorageTagBasic>::Allocate(vtkm::Id numberOfValues)
this->Array = nullptr;
this->NumberOfValues = 0;
this->AllocatedSize = 0;
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Could not allocate basic control array.");
}
@ -147,7 +147,7 @@ void Storage<T, vtkm::cont::StorageTagBasic>::Shrink(vtkm::Id numberOfValues)
{
if (numberOfValues > this->GetNumberOfValues())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Shrink method cannot be used to grow array.");
}

16
vtkm/cont/StorageImplicit.h
View File

@ -23,7 +23,7 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
@ -74,7 +74,7 @@ public:
VTKM_CONT
PortalType GetPortal()
{
throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
throw vtkm::cont::ErrorBadValue("Implicit arrays are read-only.");
}
VTKM_CONT
PortalConstType GetPortalConst() const
@ -89,12 +89,12 @@ public:
VTKM_CONT
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
throw vtkm::cont::ErrorBadValue("Implicit arrays are read-only.");
}
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue("Implicit arrays are read-only.");
throw vtkm::cont::ErrorBadValue("Implicit arrays are read-only.");
}
VTKM_CONT
void ReleaseResources()
@ -138,20 +138,20 @@ public:
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Implicit arrays cannot be used for output or in place.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Implicit arrays cannot be used for output.");
}
VTKM_CONT
void RetrieveOutputData(StorageType *vtkmNotUsed(controlArray)) const
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Implicit arrays cannot be used for output.");
}
@ -169,7 +169,7 @@ public:
VTKM_CONT
void Shrink(vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue("Implicit arrays cannot be resized.");
throw vtkm::cont::ErrorBadValue("Implicit arrays cannot be resized.");
}
VTKM_CONT

18
vtkm/cont/TryExecute.h
View File

@ -21,9 +21,9 @@
#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/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/internal/RuntimeDeviceTracker.h>
@ -59,24 +59,24 @@ struct TryExecuteRunIfValid<Functor, Device, true>
{
return functor(Device());
}
catch(vtkm::cont::ErrorControlBadAllocation e)
catch(vtkm::cont::ErrorBadAllocation e)
{
std::cerr << "caught ErrorControlBadAllocation " << e.GetMessage() << std::endl;
std::cerr << "caught ErrorBadAllocation " << 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)
catch(vtkm::cont::ErrorBadType e)
{
//should bad type errors should stop the execution, instead of
//deferring to another device adapter?
std::cerr << "caught ErrorControlBadType : " << e.GetMessage() << std::endl;
std::cerr << "caught ErrorBadType : " << e.GetMessage() << std::endl;
}
catch(vtkm::cont::ErrorControlBadValue e)
catch(vtkm::cont::ErrorBadValue e)
{
//should bad value errors should stop the filter, instead of deferring
//to another device adapter?
std::cerr << "caught ErrorControlBadValue : " << e.GetMessage() << std::endl;
std::cerr << "caught ErrorBadValue : " << e.GetMessage() << std::endl;
}
catch(vtkm::cont::Error e)
{

2
vtkm/cont/arg/TransportTagArrayIn.h
View File

@ -56,7 +56,7 @@ struct Transport<vtkm::cont::arg::TransportTagArrayIn, ContObjectType, Device>
if (object.GetNumberOfValues() != inputDomain.GetNumberOfValues())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Input array to worklet invocation the wrong size.");
}

2
vtkm/cont/arg/TransportTagArrayInOut.h
View File

@ -56,7 +56,7 @@ struct Transport<vtkm::cont::arg::TransportTagArrayInOut, ContObjectType, Device
{
if (object.GetNumberOfValues() != size)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Input array to worklet invocation the wrong size.");
}

2
vtkm/cont/arg/TransportTagTopologyFieldIn.h
View File

@ -93,7 +93,7 @@ struct Transport<
if (object.GetNumberOfValues() !=
detail::TopologyDomainSize(inputDomain, TopologyElementTag()))
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Input array to worklet invocation the wrong size.");
}

17
vtkm/cont/cuda/ArrayHandleCuda.h
View File

@ -23,8 +23,8 @@
#define vtk_m_cont_cuda_ArrayHandleCuda_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/Storage.h>
#ifdef VTKM_CUDA
@ -83,7 +83,14 @@ public:
VTKM_CONT
ValueType Get(vtkm::Id index) const
{
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"ArrayHandleCuda only provides access to the device pointer.");
}
VTKM_CONT
void Set(vtkm::Id vtkmNotUsed(index), T vtkmNotUsed(value)) const
{
throw vtkm::cont::ErrorBadType(
"ArrayHandleCuda only provides access to the device pointer.");
}
@ -148,7 +155,7 @@ public:
void Allocate(vtkm::Id size)
{
if (!this->OwnsResources())
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"ArrayHandleCuda does not own its internal device memory.");
if (NumberOfValues != 0)
@ -171,7 +178,7 @@ public:
void ReleaseResources()
{
if (!this->OwnsResources())
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"ArrayHandleCuda does not own its internal device memory.");
if (this->NumberOfValues)

2
vtkm/cont/cuda/CMakeLists.txt
View File

@ -22,7 +22,7 @@ set(headers
ArrayHandleCuda.h
ChooseCudaDevice.h
DeviceAdapterCuda.h
ErrorControlCuda.h
ErrorCuda.h
)
#-----------------------------------------------------------------------------

2
vtkm/cont/cuda/ChooseCudaDevice.h
View File

@ -22,7 +22,7 @@
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/cuda/ErrorControlCuda.h>
#include <vtkm/cont/cuda/ErrorCuda.h>
#include <cuda.h>
#include <algorithm>

22
vtkm/cont/cuda/ErrorControlCuda.h → vtkm/cont/cuda/ErrorCuda.h
View File

@ -17,18 +17,18 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_cuda_ErrorControlCuda_h
#define vtk_m_cont_cuda_ErrorControlCuda_h
#ifndef vtk_m_cont_cuda_ErrorCuda_h
#define vtk_m_cont_cuda_ErrorCuda_h
#include <vtkm/Types.h>
#include <vtkm/cont/ErrorControl.h>
#include <vtkm/cont/Error.h>
#include <cuda.h>
#include <sstream>
/// A macro that can be used to check to see if there are any unchecked
/// CUDA errors. Will throw an ErrorControlCuda if there are.
/// CUDA errors. Will throw an ErrorCuda if there are.
///
#define VTKM_CUDA_CHECK_ASYNCHRONOUS_ERROR() \
VTKM_SWALLOW_SEMICOLON_PRE_BLOCK \
@ -36,7 +36,7 @@
const cudaError_t vtkm_cuda_check_async_error = cudaGetLastError(); \
if (vtkm_cuda_check_async_error != cudaSuccess) \
{ \
throw ::vtkm::cont::cuda::ErrorControlCuda( \
throw ::vtkm::cont::cuda::ErrorCuda( \
vtkm_cuda_check_async_error, \
__FILE__, \
__LINE__, \
@ -46,7 +46,7 @@
VTKM_SWALLOW_SEMICOLON_POST_BLOCK
/// A macro that can be wrapped around a CUDA command and will throw an
/// ErrorControlCuda exception if the CUDA command fails.
/// ErrorCuda exception if the CUDA command fails.
///
#define VTKM_CUDA_CALL(command) \
VTKM_CUDA_CHECK_ASYNCHRONOUS_ERROR(); \
@ -55,7 +55,7 @@
const cudaError_t vtkm_cuda_call_error = command; \
if (vtkm_cuda_call_error != cudaSuccess) \
{ \
throw ::vtkm::cont::cuda::ErrorControlCuda(vtkm_cuda_call_error, \
throw ::vtkm::cont::cuda::ErrorCuda(vtkm_cuda_call_error, \
__FILE__, \
__LINE__, \
#command); \
@ -70,17 +70,17 @@ namespace cuda {
/// This error is thrown whenever an unidentified CUDA runtime error is
/// encountered.
///
class VTKM_ALWAYS_EXPORT ErrorControlCuda : public vtkm::cont::ErrorControl
class VTKM_ALWAYS_EXPORT ErrorCuda : public vtkm::cont::Error
{
public:
ErrorControlCuda(cudaError_t error)
ErrorCuda(cudaError_t error)
{
std::stringstream message;
message << "CUDA Error: " << cudaGetErrorString(error);
this->SetMessage(message.str());
}
ErrorControlCuda(cudaError_t error,
ErrorCuda(cudaError_t error,
const std::string &file,
vtkm::Id line,
const std::string &description)
@ -96,4 +96,4 @@ public:
}
} // namespace vtkm::cont:cuda
#endif //vtk_m_cont_cuda_ErrorControlCuda_h
#endif //vtk_m_cont_cuda_ErrorCuda_h

6
vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h
View File

@ -60,7 +60,7 @@ public:
// with nvcc 7.5.
return this->Superclass::template _PrepareForInput<void>(updateData);
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
// Thrust does not seem to be clearing the CUDA error, so do it here.
cudaError_t cudaError = cudaPeekAtLastError();
@ -81,7 +81,7 @@ public:
// with nvcc 7.5.
return this->Superclass::template _PrepareForInPlace<void>(updateData);
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
// Thrust does not seem to be clearing the CUDA error, so do it here.
cudaError_t cudaError = cudaPeekAtLastError();
@ -102,7 +102,7 @@ public:
// with nvcc 7.5.
return this->Superclass::template _PrepareForOutput<void>(numberOfValues);
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
// Thrust does not seem to be clearing the CUDA error, so do it here.
cudaError_t cudaError = cudaPeekAtLastError();

132
vtkm/cont/cuda/internal/ArrayManagerExecutionThrustDevice.h
View File

@ -21,7 +21,7 @@
#define vtk_m_cont_cuda_internal_ArrayManagerExecutionThrustDevice_h
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/Storage.h>
// Disable warnings we check vtkm for but Thrust does not.
@ -34,42 +34,29 @@ VTKM_THIRDPARTY_PRE_INCLUDE
VTKM_THIRDPARTY_POST_INCLUDE
#include <vtkm/cont/cuda/ErrorCuda.h>
#include <vtkm/cont/cuda/internal/ThrustExceptionHandler.h>
#include <vtkm/exec/cuda/internal/ArrayPortalFromThrust.h>
#include <limits>
namespace vtkm {
namespace cont {
namespace cuda {
namespace internal {
// UninitializedAllocator is an allocator which
// derives from device_allocator and which has a
// no-op construct member function
template<typename T>
struct UninitializedAllocator
: ::thrust::device_malloc_allocator<T>
{
// note that construct is annotated as
// a __host__ __device__ function
__host__ __device__
void construct(T * vtkmNotUsed(p) )
{
// no-op
}
};
/// \c ArrayManagerExecutionThrustDevice provides an implementation for a \c
/// ArrayManagerExecution class for a thrust device adapter that is designed
/// for the cuda backend which has separate memory spaces for host and device.
/// This implementation contains a thrust::system::cuda::vector to allocate
/// and manage the array.
///
/// This implementation contains a thrust::system::cuda::pointer to contain the
/// data.
template<typename T, class StorageTag>
class ArrayManagerExecutionThrustDevice
{
public:
typedef T ValueType;
typedef typename thrust::system::cuda::pointer<T>::difference_type difference_type;
typedef typename thrust::system::cuda::pointer<ValueType> PointerType;
typedef typename PointerType::difference_type difference_type;
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
@ -78,9 +65,11 @@ public:
VTKM_CONT
ArrayManagerExecutionThrustDevice(StorageType *storage)
: Storage(storage), Array()
: Storage(storage),
Begin(static_cast<ValueType*>(nullptr)),
End(static_cast<ValueType*>(nullptr)),
Capacity(static_cast<ValueType*>(nullptr))
{
}
VTKM_CONT
@ -93,7 +82,7 @@ public:
///
VTKM_CONT
vtkm::Id GetNumberOfValues() const {
return static_cast<vtkm::Id>(this->Array.size());
return static_cast<vtkm::Id>(this->End.get() - this->Begin.get());
}
/// Allocates the appropriate size of the array and copies the given data
@ -111,9 +100,7 @@ public:
// The data in this->Array should already be valid.
}
return PortalConstType(this->Array.data(),
this->Array.data() + static_cast<difference_type>(this->Array.size()));
return PortalConstType(this->Begin, this->End);
}
/// Workaround for nvcc 7.5 compiler warning bug.
@ -139,8 +126,7 @@ public:
// The data in this->Array should already be valid.
}
return PortalType(this->Array.data(),
this->Array.data() + static_cast<difference_type>(this->Array.size()));
return PortalType(this->Begin, this->End);
}
/// Workaround for nvcc 7.5 compiler warning bug.
@ -156,24 +142,55 @@ public:
VTKM_CONT
PortalType PrepareForOutput(vtkm::Id numberOfValues)
{
if (numberOfValues > this->GetNumberOfValues())
// Can we reuse the existing buffer?
vtkm::Id curCapacity = this->Begin.get() != nullptr
? static_cast<vtkm::Id>(this->Capacity.get() - this->Begin.get())
: 0;
// Just mark a new end if we don't need to increase the allocation:
if (curCapacity >= numberOfValues)
{
// Resize to 0 first so that you don't have to copy data when resizing
// to a larger size.
this->Array.clear();
this->End = PointerType(this->Begin.get() +
static_cast<difference_type>(numberOfValues));
return PortalType(this->Begin, this->End);
}
const std::size_t maxNumVals = (std::numeric_limits<std::size_t>::max() /
sizeof(ValueType));
if (static_cast<size_t>(numberOfValues) > maxNumVals)
{
std::ostringstream err;
err << "Failed to allocate " << numberOfValues << " values on device: "
<< "Number of bytes is not representable by std::size_t.";
throw vtkm::cont::ErrorBadAllocation(err.str());
}
this->ReleaseResources();
const std::size_t bufferSize = numberOfValues * sizeof(ValueType);
// Attempt to allocate:
try
{
this->Array.resize(static_cast<std::size_t>(numberOfValues));
ValueType *tmp;
VTKM_CUDA_CALL(cudaMalloc(&tmp, bufferSize));
this->Begin = PointerType(tmp);
}
catch (std::bad_alloc error)
catch (const std::exception &error)
{
throw vtkm::cont::ErrorControlBadAllocation(error.what());
std::ostringstream err;
err << "Failed to allocate " << bufferSize << " bytes on device: "
<< error.what();
throw vtkm::cont::ErrorBadAllocation(err.str());
}
return PortalType(this->Array.data(),
this->Array.data() + static_cast<difference_type>(this->Array.size()));
this->Capacity = PointerType(this->Begin.get() +
static_cast<difference_type>(numberOfValues));
this->End = this->Capacity;
return PortalType(this->Begin, this->End);
}
/// Workaround for nvcc 7.5 compiler warning bug.
@ -190,12 +207,10 @@ public:
VTKM_CONT
void RetrieveOutputData(StorageType *storage) const
{
storage->Allocate(static_cast<vtkm::Id>(this->Array.size()));
storage->Allocate(this->GetNumberOfValues());
try
{
::thrust::copy(
this->Array.data(),
this->Array.data() + static_cast<difference_type>(this->Array.size()),
::thrust::copy(this->Begin, this->End,
vtkm::cont::ArrayPortalToIteratorBegin(storage->GetPortal()));
}
catch (...)
@ -211,10 +226,7 @@ public:
template <class IteratorTypeControl>
VTKM_CONT void CopyInto(IteratorTypeControl dest) const
{
::thrust::copy(
this->Array.data(),
this->Array.data() + static_cast<difference_type>(this->Array.size()),
dest);
::thrust::copy(this->Begin, this->End, dest);
}
/// Resizes the device vector.
@ -223,18 +235,24 @@ public:
{
// The operation will succeed even if this assertion fails, but this
// is still supposed to be a precondition to Shrink.
VTKM_ASSERT(numberOfValues <= static_cast<vtkm::Id>(this->Array.size()));
VTKM_ASSERT(this->Begin.get() != nullptr &&
this->Begin.get() + numberOfValues <= this->End.get());
this->Array.resize(static_cast<std::size_t>(numberOfValues));
this->End = PointerType(this->Begin.get() +
static_cast<difference_type>(numberOfValues));
}
/// Frees all memory.
///
VTKM_CONT void ReleaseResources()
{
this->Array.clear();
this->Array.shrink_to_fit();
if (this->Begin.get() != nullptr)
{
VTKM_CUDA_CALL(cudaFree(this->Begin.get()));
this->Begin = PointerType(static_cast<ValueType*>(nullptr));
this->End = PointerType(static_cast<ValueType*>(nullptr));
this->Capacity = PointerType(static_cast<ValueType*>(nullptr));
}
}
private:
@ -246,17 +264,19 @@ private:
StorageType *Storage;
::thrust::system::cuda::vector<ValueType,
UninitializedAllocator<ValueType> > Array;
PointerType Begin;
PointerType End;
PointerType Capacity;
VTKM_CONT
void CopyToExecution()
{
try
{
this->Array.assign(
vtkm::cont::ArrayPortalToIteratorBegin(this->Storage->GetPortalConst()),
vtkm::cont::ArrayPortalToIteratorEnd(this->Storage->GetPortalConst()));
this->PrepareForOutput(this->Storage->GetNumberOfValues());
::thrust::copy(vtkm::cont::ArrayPortalToIteratorBegin(this->Storage->GetPortalConst()),
vtkm::cont::ArrayPortalToIteratorEnd(this->Storage->GetPortalConst()),
this->Begin);
}
catch (...)
{

2
vtkm/cont/cuda/internal/DeviceAdapterAlgorithmCuda.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_cont_cuda_internal_DeviceAdapterAlgorithmCuda_h
#define vtk_m_cont_cuda_internal_DeviceAdapterAlgorithmCuda_h
#include <vtkm/cont/cuda/ErrorControlCuda.h>
#include <vtkm/cont/cuda/ErrorCuda.h>
#include <vtkm/cont/cuda/internal/DeviceAdapterTagCuda.h>
#include <vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h>

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

@ -28,7 +28,7 @@
#include <vtkm/TypeTraits.h>
#include <vtkm/UnaryPredicates.h>
#include <vtkm/cont/cuda/ErrorControlCuda.h>
#include <vtkm/cont/cuda/ErrorCuda.h>
#include <vtkm/cont/cuda/internal/MakeThrustIterator.h>
#include <vtkm/cont/cuda/internal/ThrustExceptionHandler.h>

4
vtkm/cont/cuda/internal/ThrustExceptionHandler.h
View File

@ -21,7 +21,7 @@
#define vtk_m_cont_cuda_interal_ThrustExecptionHandler_h
#include <vtkm/internal/ExportMacros.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorExecution.h>
VTKM_THIRDPARTY_PRE_INCLUDE
@ -43,7 +43,7 @@ static inline void throwAsVTKmException()
}
catch(std::bad_alloc &error)
{
throw vtkm::cont::ErrorControlBadAllocation(error.what());
throw vtkm::cont::ErrorBadAllocation(error.what());
}
catch(thrust::system_error &error)
{

4
vtkm/cont/internal/ArrayHandleExecutionManager.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_cont_exec_ArrayHandleExecutionManager_h
#define vtk_m_cont_exec_ArrayHandleExecutionManager_h
#include <vtkm/cont/ErrorControlInternal.h>
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
@ -192,7 +192,7 @@ private:
{
if (!this->IsDeviceAdapter(device))
{
throw vtkm::cont::ErrorControlInternal("Device Adapter Mismatch");
throw vtkm::cont::ErrorInternal("Device Adapter Mismatch");
}
}
};

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

@ -24,7 +24,7 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayPortal.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <iterator>
#include <limits>
@ -65,7 +65,7 @@ public:
#ifndef VTKM_USE_64BIT_IDS
if (numberOfValues > (std::numeric_limits<vtkm::Id>::max)())
{
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Distance of iterators larger than maximum array size. "
"To support larger arrays, try turning on VTKM_USE_64BIT_IDS.");
}
@ -149,7 +149,7 @@ public:
#ifndef VTKM_USE_64BIT_IDS
if (numberOfValues > (std::numeric_limits<vtkm::Id>::max)())
{
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Distance of iterators larger than maximum array size. "
"To support larger arrays, try turning on VTKM_USE_64BIT_IDS.");
}
@ -181,6 +181,15 @@ public:
return *this->IteratorAt(index);
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
void Set(vtkm::Id vtkmNotUsed(index), const ValueType& vtkmNotUsed(value)) const
{
#if ! (defined(VTKM_MSVC) && defined(VTKM_CUDA))
VTKM_ASSERT(false && "Attempted to write to constant array.");
#endif
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
IteratorT GetIteratorBegin() const {

2
vtkm/cont/internal/ConnectivityExplicitInternals.h
View File

@ -133,7 +133,7 @@ struct ConnectivityExplicitInternals
{
if (!this->IndexOffsetsValid)
{
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"Cannot build indices using the error device. Must be created previously.");
}
}

4
vtkm/cont/internal/RuntimeDeviceTracker.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_cont_internal_RuntimeDeviceTracker_h
#define vtk_m_cont_internal_RuntimeDeviceTracker_h
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/RuntimeDeviceInformation.h>
#include <vtkm/cont/DeviceAdapter.h>
@ -67,7 +67,7 @@ public:
template<typename DeviceAdapterTag>
VTKM_CONT
void ReportAllocationFailure(DeviceAdapterTag,
const vtkm::cont::ErrorControlBadAllocation&)
const vtkm::cont::ErrorBadAllocation&)
{
typedef vtkm::cont::DeviceAdapterTraits<DeviceAdapterTag> Traits;
this->RuntimeValid[ Traits::GetId() ] = false;

1
vtkm/cont/testing/CMakeLists.txt
View File

@ -36,6 +36,7 @@ set(unit_tests
UnitTestArrayHandleCartesianProduct.cxx
UnitTestArrayHandleCompositeVector.cxx
UnitTestArrayHandleCounting.cxx
UnitTestArrayHandleDiscard.cxx
UnitTestArrayHandleImplicit.cxx
UnitTestArrayHandleIndex.cxx
UnitTestArrayHandlePermutation.cxx

2
vtkm/cont/testing/TestingDataSetExplicit.h
View File

@ -90,7 +90,7 @@ private:
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_POINTS);
VTKM_TEST_FAIL("Failed to get expected error for association mismatch.");
}
catch (vtkm::cont::ErrorControlBadValue error)
catch (vtkm::cont::ErrorBadValue error)
{
std::cout << "Caught expected error for association mismatch: "
<< std::endl << " " << error.GetMessage() << std::endl;

4
vtkm/cont/testing/TestingDeviceAdapter.h
View File

@ -30,7 +30,7 @@
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleZip.h>
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/RuntimeDeviceInformation.h>
#include <vtkm/cont/StorageBasic.h>
@ -423,7 +423,7 @@ private:
"or the width of vtkm::Id is not large enough to express all "
"array sizes.");
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
std::cout << "Got the expected error: " << error.GetMessage() << std::endl;
}

40
vtkm/cont/testing/TestingFancyArrayHandles.h
View File

@ -28,6 +28,7 @@
#include <vtkm/cont/ArrayHandleConcatenate.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/ArrayHandleDiscard.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/cont/ArrayHandleGroupVecVariable.h>
#include <vtkm/cont/ArrayHandleImplicit.h>
@ -303,7 +304,7 @@ private:
{
vtkm::Id implicitLen = length - start_pos;
vtkm::Id basicLen = start_pos;
// make an implicit array
ValueHandleType implicit =
vtkm::cont::make_ArrayHandleImplicit<ValueType>(functor,
@ -796,6 +797,37 @@ private:
}
};
struct TestDiscardAsOutput
{
template< typename ValueType>
VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const
{
using DiscardHandleType = vtkm::cont::ArrayHandleDiscard<ValueType>;
using ComponentType = typename vtkm::VecTraits<ValueType>::ComponentType;
typedef typename vtkm::cont::ArrayHandle<ValueType>::PortalControl Portal;
const vtkm::Id length = ARRAY_SIZE;
vtkm::cont::ArrayHandle<ValueType> input;
input.Allocate(length);
Portal inputPortal = input.GetPortalControl();
for(vtkm::Id i=0; i < length; ++i)
{
inputPortal.Set(i,ValueType(ComponentType(i)));
}
DiscardHandleType discard;
discard.Allocate(length);
vtkm::worklet::DispatcherMapField< PassThrough, DeviceAdapterTag > dispatcher;
dispatcher.Invoke(input, discard);
// No output to verify since none is stored in memory. Just checking that
// this compiles/runs without errors.
}
};
struct TestPermutationAsOutput
{
template< typename ValueType>
@ -1036,6 +1068,12 @@ private:
TestingFancyArrayHandles<DeviceAdapterTag>::TestPermutationAsOutput(),
HandleTypesToTest());
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing ArrayHandleDiscard as Output" << std::endl;
vtkm::testing::Testing::TryTypes(
TestingFancyArrayHandles<DeviceAdapterTag>::TestDiscardAsOutput(),
HandleTypesToTest());
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing ArrayHandleZip as Output" << std::endl;
vtkm::testing::Testing::TryTypes(

2
vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx
View File

@ -331,7 +331,7 @@ void TestBadArrayLengths() {
vtkm::cont::make_ArrayHandleCompositeVector(longInArray,0, shortInArray,0);
VTKM_TEST_FAIL("Did not get exception like expected.");
}
catch (vtkm::cont::ErrorControlBadValue error)
catch (vtkm::cont::ErrorBadValue error)
{
std::cout << "Got expected error: " << std::endl
<< error.GetMessage() << std::endl;

143
vtkm/cont/testing/UnitTestArrayHandleDiscard.cxx Normal file
View File

@ -0,0 +1,143 @@
//============================================================================
// 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 2017 Sandia Corporation.
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 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/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleDiscard.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/serial/internal/ArrayManagerExecutionSerial.h>
#include <vtkm/cont/serial/internal/DeviceAdapterAlgorithmSerial.h>
#include <vtkm/cont/serial/internal/DeviceAdapterTagSerial.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/BinaryOperators.h>
#include <algorithm>
namespace UnitTestArrayHandleDiscardDetail
{
template <typename ValueType>
struct Test
{
static const vtkm::Id ARRAY_SIZE = 100;
static const vtkm::Id NUM_KEYS = 3;
using DeviceTag = vtkm::cont::DeviceAdapterTagSerial;
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<DeviceTag>;
using Handle = vtkm::cont::ArrayHandle<ValueType>;
using DiscardHandle = vtkm::cont::ArrayHandleDiscard<ValueType>;
using OutputPortal = typename Handle::PortalControl;
using ReduceOp = vtkm::Add;
// Test discard arrays by using the ReduceByKey algorithm. Two regular arrays
// handles are provided as inputs, but the keys_output array is a discard
// array handle. The values_output array should still be populated correctly.
void TestReduceByKey()
{
// The reduction operator:
ReduceOp op;
// Prepare inputs / reference data:
ValueType keyData[ARRAY_SIZE];
ValueType valueData[ARRAY_SIZE];
ValueType refData[NUM_KEYS];
std::fill(refData, refData + NUM_KEYS, ValueType(0));
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Id key = i % NUM_KEYS;
keyData[i] = static_cast<ValueType>(key);
valueData[i] = static_cast<ValueType>(i * 2);
refData[key] = op(refData[key], valueData[i]);
}
// Prepare array handles:
Handle keys = vtkm::cont::make_ArrayHandle(keyData, ARRAY_SIZE);
Handle values = vtkm::cont::make_ArrayHandle(valueData, ARRAY_SIZE);
DiscardHandle output_keys;
Handle output_values;
Algorithm::SortByKey(keys, values);
Algorithm::ReduceByKey(keys, values, output_keys, output_values, op);
OutputPortal outputs = output_values.GetPortalControl();
VTKM_TEST_ASSERT(outputs.GetNumberOfValues() == NUM_KEYS,
"Unexpected number of output values from ReduceByKey.");
for (vtkm::Id i = 0; i < NUM_KEYS; ++i)
{
VTKM_TEST_ASSERT(outputs.Get(i) == refData[i],
"Unexpected output value after ReduceByKey.");
}
}
void TestPrepareExceptions()
{
DiscardHandle handle;
handle.Allocate(50);
try
{
handle.PrepareForInput(DeviceTag());
}
catch (vtkm::cont::ErrorBadValue exp)
{
// Expected failure.
}
try
{
handle.PrepareForInPlace(DeviceTag());
}
catch (vtkm::cont::ErrorBadValue exp)
{
// Expected failure.
}
// Shouldn't fail:
handle.PrepareForOutput(ARRAY_SIZE, DeviceTag());
}
void operator()()
{
TestReduceByKey();
TestPrepareExceptions();
}
};
void TestArrayHandleDiscard()
{
Test<vtkm::UInt8>()();
Test<vtkm::Int16>()();
Test<vtkm::Int32>()();
Test<vtkm::Int64>()();
Test<vtkm::Float32>()();
Test<vtkm::Float64>()();
}
} // end namespace UnitTestArrayHandleDiscardDetail
int UnitTestArrayHandleDiscard(int, char *[])
{
using namespace UnitTestArrayHandleDiscardDetail;
return vtkm::cont::testing::Testing::Run(TestArrayHandleDiscard);
}

276
vtkm/cont/testing/UnitTestDataSetBuilderExplicit.cxx
View File

@ -23,6 +23,7 @@
#include <vtkm/cont/DataSetBuilderExplicit.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/ExplicitTestData.h>
#include <vector>
@ -50,42 +51,63 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
vtkm::Id numCells,
const vtkm::Bounds &bounds)
{
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 0,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Make sure bounds are correct.
vtkm::Bounds computedBounds =
ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, computedBounds),
"Bounds of coordinates do not match");
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'pointvar' with ASSOC_POINT_SET.");
}
//Make sure bounds are correct.
vtkm::Bounds computedBounds =
ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, computedBounds),
"Bounds of coordinates do not match");
}
template <typename T>
std::vector<T>
createVec(std::size_t n, const T *data)
{
std::vector<T> vec(n);
for (std::size_t i = 0; i < n; i++)
vec[i] = data[i];
return vec;
std::vector<T> vec(n);
for (std::size_t i = 0; i < n; i++)
{
vec[i] = data[i];
}
return vec;
}
template <typename T>
vtkm::cont::ArrayHandle<T>
createAH(std::size_t n, const T *data)
{
vtkm::cont::ArrayHandle<T> arr;
DFA::Copy(vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n)), arr);
return arr;
vtkm::cont::ArrayHandle<T> arr;
DFA::Copy(vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n)), arr);
return arr;
}
template <typename T>
@ -97,42 +119,63 @@ CreateDataSetArr(bool useSeparatedCoords,
const vtkm::IdComponent *indices,
const vtkm::UInt8 *shape)
{
vtkm::cont::DataSetBuilderExplicit dsb;
if (useSeparatedCoords)
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
vtkm::cont::DataSetBuilderExplicit dsb;
if (useSeparatedCoords)
{
std::vector<T> xvals(numPoints), yvals(numPoints), zvals(numPoints);
std::vector<T> varP(numPoints), varC(numCells);
for (std::size_t i = 0; i < numPoints; i++)
{
std::vector<T> xvals(numPoints), yvals(numPoints), zvals(numPoints);
for (std::size_t i = 0; i < numPoints; i++)
{
xvals[i] = coords[i*3 + 0];
yvals[i] = coords[i*3 + 1];
zvals[i] = coords[i*3 + 2];
}
vtkm::cont::ArrayHandle<T> X,Y,Z;
DFA::Copy(vtkm::cont::make_ArrayHandle(xvals), X);
DFA::Copy(vtkm::cont::make_ArrayHandle(yvals), Y);
DFA::Copy(vtkm::cont::make_ArrayHandle(zvals), Z);
return dsb.Create(X,Y,Z,
createAH(numCells, shape),
createAH(numCells, indices),
createAH(numConn, conn));
xvals[i] = coords[i*3 + 0];
yvals[i] = coords[i*3 + 1];
zvals[i] = coords[i*3 + 2];
varP[i] = static_cast<T>(i*1.1f);
}
else
for (std::size_t i = 0; i < numCells; i++)
{
std::vector<vtkm::Vec<T,3> > tmp(numPoints);
for (std::size_t i = 0; i < numPoints; i++)
{
tmp[i][0] = coords[i*3 + 0];
tmp[i][1] = coords[i*3 + 1];
tmp[i][2] = coords[i*3 + 2];
}
vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > pts;
DFA::Copy(vtkm::cont::make_ArrayHandle(tmp), pts);
return dsb.Create(pts,
createAH(numCells, shape),
createAH(numCells, indices),
createAH(numConn, conn));
varC[i] = static_cast<T>(i*1.1f);
}
vtkm::cont::ArrayHandle<T> X,Y,Z,P,C;
DFA::Copy(vtkm::cont::make_ArrayHandle(xvals), X);
DFA::Copy(vtkm::cont::make_ArrayHandle(yvals), Y);
DFA::Copy(vtkm::cont::make_ArrayHandle(zvals), Z);
DFA::Copy(vtkm::cont::make_ArrayHandle(varP), P);
DFA::Copy(vtkm::cont::make_ArrayHandle(varC), C);
dataSet = dsb.Create(X,Y,Z,
createAH(numCells, shape),
createAH(numCells, indices),
createAH(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", P);
dsf.AddCellField(dataSet, "cellvar", C);
return dataSet;
}
else
{
std::vector<vtkm::Vec<T,3> > tmp(numPoints);
std::vector<vtkm::Vec<T,1> > varP(numPoints), varC(numCells);
for (std::size_t i = 0; i < numPoints; i++)
{
tmp[i][0] = coords[i*3 + 0];
tmp[i][1] = coords[i*3 + 1];
tmp[i][2] = coords[i*3 + 2];
varP[i][0] = static_cast<T>(i*1.1f);
}
for (std::size_t i = 0; i < numCells; i++)
{
varC[i][0] = static_cast<T>(i*1.1f);
}
vtkm::cont::ArrayHandle<vtkm::Vec<T,3> > pts;
DFA::Copy(vtkm::cont::make_ArrayHandle(tmp), pts);
dataSet = dsb.Create(pts,
createAH(numCells, shape),
createAH(numCells, indices),
createAH(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
return dataSet;
}
}
template <typename T>
@ -144,36 +187,55 @@ CreateDataSetVec(bool useSeparatedCoords,
const vtkm::IdComponent *indices,
const vtkm::UInt8 *shape)
{
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
vtkm::cont::DataSetBuilderExplicit dsb;
if (useSeparatedCoords)
if (useSeparatedCoords)
{
std::vector<T> X(numPoints), Y(numPoints), Z(numPoints), varP(numPoints), varC(numCells);
for (std::size_t i = 0; i < numPoints; i++)
{
std::vector<T> X(numPoints), Y(numPoints), Z(numPoints);
for (std::size_t i = 0; i < numPoints; i++)
{
X[i] = coords[i*3 + 0];
Y[i] = coords[i*3 + 1];
Z[i] = coords[i*3 + 2];
}
return dsb.Create(X,Y,Z,
createVec(numCells, shape),
createVec(numCells, indices),
createVec(numConn, conn));
X[i] = coords[i*3 + 0];
Y[i] = coords[i*3 + 1];
Z[i] = coords[i*3 + 2];
varP[i] = static_cast<T>(i*1.1f);
}
else
for (std::size_t i = 0; i < numCells; i++)
{
std::vector<vtkm::Vec<T,3> > pts(numPoints);
for (std::size_t i = 0; i < numPoints; i++)
{
pts[i][0] = coords[i*3 + 0];
pts[i][1] = coords[i*3 + 1];
pts[i][2] = coords[i*3 + 2];
}
return dsb.Create(pts,
createVec(numCells, shape),
createVec(numCells, indices),
createVec(numConn, conn));
varC[i] = static_cast<T>(i*1.1f);
}
dataSet = dsb.Create(X,Y,Z,
createVec(numCells, shape),
createVec(numCells, indices),
createVec(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
return dataSet;
}
else
{
std::vector<vtkm::Vec<T,3> > pts(numPoints);
std::vector<vtkm::Vec<T,1> > varP(numPoints), varC(numCells);
for (std::size_t i = 0; i < numPoints; i++)
{
pts[i][0] = coords[i*3 + 0];
pts[i][1] = coords[i*3 + 1];
pts[i][2] = coords[i*3 + 2];
varP[i][0] = static_cast<T>(i*1.1f);
}
for (std::size_t i = 0; i < numCells; i++)
{
varC[i][0] = static_cast<T>(i*1.1f);
}
dataSet = dsb.Create(pts,
createVec(numCells, shape),
createVec(numCells, indices),
createVec(numConn, conn));
dsf.AddPointField(dataSet, "pointvar", varP);
dsf.AddCellField(dataSet, "cellvar", varC);
return dataSet;
}
}
#define TEST_DATA(num) \
@ -194,40 +256,40 @@ CreateDataSetVec(bool useSeparatedCoords,
void
TestDataSetBuilderExplicit()
{
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSet ds;
vtkm::Bounds bounds;
vtkm::cont::DataSetBuilderExplicit dsb;
vtkm::cont::DataSet ds;
vtkm::Bounds bounds;
//Iterate over organization of coordinates.
for (int i = 0; i < 2; i++)
{
//Test ExplicitData0
bounds = ComputeBounds(TEST_BOUNDS(0));
ds = CreateDataSetArr(i==0,TEST_DATA(0));
ValidateDataSet(ds, TEST_NUMS(0), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(0));
ValidateDataSet(ds, TEST_NUMS(0), bounds);
//Iterate over organization of coordinates.
for (int i = 0; i < 2; i++)
{
//Test ExplicitData0
bounds = ComputeBounds(TEST_BOUNDS(0));
ds = CreateDataSetArr(i==0,TEST_DATA(0));
ValidateDataSet(ds, TEST_NUMS(0), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(0));
ValidateDataSet(ds, TEST_NUMS(0), bounds);
//Test ExplicitData1
bounds = ComputeBounds(TEST_BOUNDS(1));
ds = CreateDataSetArr(i==0,TEST_DATA(1));
ValidateDataSet(ds, TEST_NUMS(1), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(1));
ValidateDataSet(ds, TEST_NUMS(1), bounds);
//Test ExplicitData1
bounds = ComputeBounds(TEST_BOUNDS(1));
ds = CreateDataSetArr(i==0,TEST_DATA(1));
ValidateDataSet(ds, TEST_NUMS(1), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(1));
ValidateDataSet(ds, TEST_NUMS(1), bounds);
//Test ExplicitData2
bounds = ComputeBounds(TEST_BOUNDS(2));
ds = CreateDataSetArr(i==0,TEST_DATA(2));
ValidateDataSet(ds, TEST_NUMS(2), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(2));
ValidateDataSet(ds, TEST_NUMS(2), bounds);
}
//Test ExplicitData2
bounds = ComputeBounds(TEST_BOUNDS(2));
ds = CreateDataSetArr(i==0,TEST_DATA(2));
ValidateDataSet(ds, TEST_NUMS(2), bounds);
ds = CreateDataSetVec(i==0, TEST_DATA(2));
ValidateDataSet(ds, TEST_NUMS(2), bounds);
}
}
} // namespace DataSetBuilderExplicitNamespace
int UnitTestDataSetBuilderExplicit(int, char *[])
{
using namespace DataSetBuilderExplicitNamespace;
return vtkm::cont::testing::Testing::Run(TestDataSetBuilderExplicit);
using namespace DataSetBuilderExplicitNamespace;
return vtkm::cont::testing::Testing::Run(TestDataSetBuilderExplicit);
}

125
vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
View File

@ -24,7 +24,7 @@
#include <vtkm/cont/DataSetBuilderRectilinear.h>
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
#include <ctime>
@ -43,36 +43,55 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
vtkm::Id numPoints, vtkm::Id numCells,
const vtkm::Bounds &bounds)
{
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 0,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Make sure the bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
if (dim == 2)
{
vtkm::cont::CellSetStructured<2> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_QUAD, "Wrong element type");
}
else if (dim == 3)
{
vtkm::cont::CellSetStructured<3> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_HEXAHEDRON, "Wrong element type");
}
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'pointvar' with ASSOC_POINT_SET.");
}
//Make sure the bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
if (dim == 2)
{
vtkm::cont::CellSetStructured<2> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_QUAD, "Wrong element type");
}
else if (dim == 3)
{
vtkm::cont::CellSetStructured<3> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_HEXAHEDRON, "Wrong element type");
}
}
template <typename T>
@ -108,6 +127,7 @@ RectilinearTests()
vtkm::cont::DataSetBuilderRectilinear dataSetBuilder;
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
std::uniform_int_distribution<vtkm::Id> randomDim(2,MAX_DIM_SIZE);
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0,NUM_FILL_METHODS-1);
@ -142,18 +162,41 @@ RectilinearTests()
std::cout << "1D cases" << std::endl;
numPoints = dimensions[0];
numCells = dimensions[0]-1;
std::vector<T> varP1D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP1D[i] = static_cast<T>(i*1.1f);
}
std::vector<T> varC1D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC1D[i] = static_cast<T>(i*1.1f);
}
bounds.X = vtkm::Range(xCoordinates.front(), xCoordinates.back());
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP1D);
dsf.AddCellField(dataSet, "cellvar", varC1D);
ValidateDataSet(dataSet, 1, numPoints, numCells, bounds);
std::cout << "2D cases" << std::endl;
numPoints = dimensions[0]*dimensions[1];
numCells = (dimensions[0]-1)*(dimensions[1]-1);
std::vector<T> varP2D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP2D[i] = static_cast<T>(i*1.1f);
}
std::vector<T> varC2D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC2D[i] = static_cast<T>(i*1.1f);
}
bounds.Y = vtkm::Range(yCoordinates.front(), yCoordinates.back());
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates, yCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP2D);
dsf.AddCellField(dataSet, "cellvar", varC2D);
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
std::cout << " Create with C array" << std::endl;
@ -161,20 +204,36 @@ RectilinearTests()
dimensions[1],
&xCoordinates.front(),
&yCoordinates.front());
dsf.AddPointField(dataSet, "pointvar", &varP2D.front(), numPoints);
dsf.AddCellField(dataSet, "cellvar", &varC2D.front(), numCells);
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates));
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP2D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC2D));
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
std::cout << "3D cases" << std::endl;
numPoints *= dimensions[2];
numCells *= dimensions[2]-1;
std::vector<T> varP3D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP3D[i] = static_cast<T>(i*1.1f);;
}
std::vector<T> varC3D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC3D[i] = static_cast<T>(i*1.1f);
}
bounds.Z = vtkm::Range(zCoordinates.front(), zCoordinates.back());
std::cout << " Create with std::vector" << std::endl;
dataSet = dataSetBuilder.Create(xCoordinates, yCoordinates, zCoordinates);
dsf.AddPointField(dataSet, "pointvar", varP3D);
dsf.AddCellField(dataSet, "cellvar", varC3D);
ValidateDataSet(dataSet, 3, numPoints, numCells, bounds);
std::cout << " Create with C array" << std::endl;
@ -184,12 +243,16 @@ RectilinearTests()
&xCoordinates.front(),
&yCoordinates.front(),
&zCoordinates.front());
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC3D));
ValidateDataSet(dataSet, 3, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates),
vtkm::cont::make_ArrayHandle(zCoordinates));
dsf.AddPointField(dataSet, "pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dsf.AddCellField(dataSet, "cellvar", vtkm::cont::make_ArrayHandle(varC3D));
ValidateDataSet(dataSet, 3, numPoints, numCells, bounds);
}
}

128
vtkm/cont/testing/UnitTestDataSetBuilderUniform.cxx
View File

@ -25,7 +25,6 @@
#include <vtkm/cont/DeviceAdapterAlgorithm.h>
#include <vtkm/cont/DynamicCellSet.h>
#include <vtkm/cont/testing/MakeTestDataSet.h>
#include <vtkm/cont/testing/Testing.h>
#include <time.h>
@ -44,44 +43,62 @@ void ValidateDataSet(const vtkm::cont::DataSet &ds,
vtkm::Id numPoints, vtkm::Id numCells,
vtkm::Bounds bounds)
{
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 0,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Verify basics..
VTKM_TEST_ASSERT(ds.GetNumberOfCellSets() == 1,
"Wrong number of cell sets.");
VTKM_TEST_ASSERT(ds.GetNumberOfFields() == 2,
"Wrong number of fields.");
VTKM_TEST_ASSERT(ds.GetNumberOfCoordinateSystems() == 1,
"Wrong number of coordinate systems.");
VTKM_TEST_ASSERT(ds.GetCoordinateSystem().GetData().GetNumberOfValues() == numPoints,
"Wrong number of coordinates.");
VTKM_TEST_ASSERT(ds.GetCellSet().GetNumberOfCells() == numCells,
"Wrong number of cells.");
//Make sure bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
// test various field-getting methods and associations
try
{
ds.GetField("cellvar", vtkm::cont::Field::ASSOC_CELL_SET);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'cellvar' with ASSOC_CELL_SET.");
}
if (dim == 1)
{
vtkm::cont::CellSetStructured<1> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_LINE, "Wrong element type");
}
else if (dim == 2)
{
vtkm::cont::CellSetStructured<2> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_QUAD, "Wrong element type");
}
else if (dim == 3)
{
vtkm::cont::CellSetStructured<3> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_HEXAHEDRON, "Wrong element type");
}
try
{
ds.GetField("pointvar", vtkm::cont::Field::ASSOC_POINTS);
}
catch (...)
{
VTKM_TEST_FAIL("Failed to get field 'pointvar' with ASSOC_POINT_SET.");
}
//Make sure bounds are correct.
vtkm::Bounds res = ds.GetCoordinateSystem().GetBounds(DeviceAdapter());
VTKM_TEST_ASSERT(test_equal(bounds, res),
"Bounds of coordinates do not match");
if (dim == 1)
{
vtkm::cont::CellSetStructured<1> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_LINE, "Wrong element type");
}
else if (dim == 2)
{
vtkm::cont::CellSetStructured<2> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_QUAD, "Wrong element type");
}
else if (dim == 3)
{
vtkm::cont::CellSetStructured<3> cellSet;
ds.GetCellSet(0).CopyTo(cellSet);
vtkm::IdComponent shape = cellSet.GetCellShape();
VTKM_TEST_ASSERT(shape == vtkm::CELL_SHAPE_HEXAHEDRON, "Wrong element type");
}
}
template <typename T>
@ -130,6 +147,7 @@ UniformTests()
vtkm::cont::DataSetBuilderUniform dataSetBuilder;
vtkm::cont::DataSet dataSet;
vtkm::cont::DataSetFieldAdd dsf;
std::uniform_int_distribution<vtkm::Id> randomDim(2, MAX_DIM_SIZE);
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0, NUM_FILL_METHODS-1);
@ -170,16 +188,40 @@ UniformTests()
std::cout << "3D case" << std::endl;
vtkm::Id numPoints = dimensions[0]*dimensions[1]*dimensions[2];
vtkm::Id numCells = (dimensions[0]-1)*(dimensions[1]-1)*(dimensions[2]-1);
std::vector<T> varP3D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP3D[i] = static_cast<T>(i*1.1f);
}
std::vector<T> varC3D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC3D[i] = static_cast<T>(i*1.1f);
}
dataSet = dataSetBuilder.Create(dimensions, origin, spacing);
dsf.AddPointField(dataSet, "pointvar", varP3D);
dsf.AddCellField(dataSet, "cellvar", varC3D);
ValidateDataSet(dataSet, 3, numPoints, numCells, bounds);
std::cout << "2D case" << std::endl;
numPoints = dimensions[0]*dimensions[1];
numCells = (dimensions[0]-1)*(dimensions[1]-1);
bounds.Z = vtkm::Range(0, 0);
std::vector<T> varP2D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP2D[i] = static_cast<T>(i*1.1f);
}
std::vector<T> varC2D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC2D[i] = static_cast<T>(i*1.1f);
}
dataSet = dataSetBuilder.Create(vtkm::Id2(dimensions[0], dimensions[1]),
vtkm::Vec<T,2>(origin[0], origin[1]),
vtkm::Vec<T,2>(spacing[0], spacing[1]));
dsf.AddPointField(dataSet, "pointvar", varP2D);
dsf.AddCellField(dataSet, "cellvar", varC2D);
ValidateDataSet(dataSet, 2, numPoints, numCells, bounds);
std::cout << "1D case" <<std::endl;
@ -187,7 +229,19 @@ UniformTests()
numCells = dimensions[0]-1;
bounds.Y = vtkm::Range(0, 0);
bounds.Z = vtkm::Range(0, 0);
std::vector<T> varP1D(static_cast<unsigned long>(numPoints));
for (unsigned long i = 0; i < static_cast<unsigned long>(numPoints); i++)
{
varP1D[i] = static_cast<T>(i*1.1f);
}
std::vector<T> varC1D(static_cast<unsigned long>(numCells));
for (unsigned long i = 0; i < static_cast<unsigned long>(numCells); i++)
{
varC1D[i] = static_cast<T>(i*1.1f);
}
dataSet = dataSetBuilder.Create(dimensions[0], origin[0], spacing[0]);
dsf.AddPointField(dataSet, "pointvar", varP1D);
dsf.AddCellField(dataSet, "cellvar", varC1D);
ValidateDataSet(dataSet, 1, numPoints, numCells, bounds);
}
}

12
vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx
View File

@ -263,7 +263,7 @@ void TryUnusualType()
CheckDynamicArray(array, 1);
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
std::cout << " Caught exception for unrecognized type." << std::endl;
}
@ -285,7 +285,7 @@ void TryUnusualStorage()
CheckDynamicArray(array, 1);
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
std::cout << " Caught exception for unrecognized storage." << std::endl;
}
@ -306,7 +306,7 @@ void TryUnusualTypeAndStorage()
VTKM_TEST_FAIL(
"CastAndCall failed to error for unrecognized type/storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
std::cout << " Caught exception for unrecognized type/storage."
<< std::endl;
@ -317,7 +317,7 @@ void TryUnusualTypeAndStorage()
CheckDynamicArray(array.ResetTypeList(TypeListTagString()), 1);
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
std::cout << " Caught exception for unrecognized storage." << std::endl;
}
@ -327,7 +327,7 @@ void TryUnusualTypeAndStorage()
CheckDynamicArray(array.ResetStorageList(StorageListTagUnusual()), 1);
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
std::cout << " Caught exception for unrecognized type." << std::endl;
}
@ -339,7 +339,7 @@ void TryUnusualTypeAndStorage()
StorageListTagUnusual()),
1);
}
catch (vtkm::cont::ErrorControlBadValue)
catch (vtkm::cont::ErrorBadValue)
{
VTKM_TEST_FAIL("ResetTypeAndStorageLists should have handled the custom type/storage.");
}

2
vtkm/cont/testing/UnitTestStorageBasic.cxx
View File

@ -182,7 +182,7 @@ struct TemplatedTests
VTKM_TEST_ASSERT(true==false,
"Array shrink do a larger size was possible. This can't be allowed.");
}
catch(vtkm::cont::ErrorControlBadValue) {}
catch(vtkm::cont::ErrorBadValue) {}
}
void operator()()

4
vtkm/cont/testing/UnitTestStorageImplicit.cxx
View File

@ -85,7 +85,7 @@ struct TemplatedTests
VTKM_TEST_ASSERT(false == true,
"Implicit Storage Allocate method didn't throw error.");
}
catch(vtkm::cont::ErrorControlBadValue e) {}
catch(vtkm::cont::ErrorBadValue e) {}
try
{
@ -93,7 +93,7 @@ struct TemplatedTests
VTKM_TEST_ASSERT(true==false,
"Array shrink do a larger size was possible. This can't be allowed.");
}
catch(vtkm::cont::ErrorControlBadValue) {}
catch(vtkm::cont::ErrorBadValue) {}
//verify that calling ReleaseResources doesn't throw an exception
arrayStorage.ReleaseResources();

16
vtkm/exec/cuda/internal/ArrayPortalFromThrust.h
View File

@ -337,18 +337,24 @@ public:
ValueType Get(vtkm::Id index) const {
return vtkm::exec::cuda::internal::load_through_texture<ValueType>::get( this->BeginIterator + index );
}
__device__
void Set(vtkm::Id vtkmNotUsed(index), ValueType vtkmNotUsed(value)) const {
}
#else
__host__
ValueType Get(vtkm::Id vtkmNotUsed(index) ) const {
return ValueType();
}
__host__
void Set(vtkm::Id vtkmNotUsed(index), ValueType vtkmNotUsed(value)) const {
#if ! (defined(VTKM_MSVC) && defined(VTKM_CUDA))
VTKM_ASSERT(true && "Cannot set to const array.");
#endif
__host__ __device__
void Set(vtkm::Id index, ValueType value) const {
*(this->BeginIterator + index) = value;
}
#endif
VTKM_EXEC_CONT
IteratorType GetIteratorBegin() const { return this->BeginIterator; }

2
vtkm/filter/FilterDataSet.hxx
View File

@ -26,7 +26,7 @@
#include <vtkm/filter/internal/ResolveFieldTypeAndMap.h>
#include <vtkm/cont/Error.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>

2
vtkm/filter/FilterDataSetWithField.hxx
View File

@ -26,7 +26,7 @@
#include <vtkm/filter/internal/ResolveFieldTypeAndMap.h>
#include <vtkm/cont/Error.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>

2
vtkm/filter/FilterField.hxx
View File

@ -25,7 +25,7 @@
#include <vtkm/filter/internal/ResolveFieldTypeAndExecute.h>
#include <vtkm/cont/Error.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>

4
vtkm/interop/cuda/internal/TransferToOpenGL.h
View File

@ -21,7 +21,7 @@
#define vtkm_interop_cuda_internal_TransferToOpenGL_h
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/ErrorControlBadAllocation.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/cuda/internal/DeviceAdapterTagCuda.h>
#include <vtkm/cont/cuda/internal/MakeThrustIterator.h>
@ -91,7 +91,7 @@ public:
cudaError_t cError =cudaGraphicsMapResources(1,&this->CudaResource);
if(cError != cudaSuccess)
{
throw vtkm::cont::ErrorControlBadAllocation(
throw vtkm::cont::ErrorBadAllocation(
"Could not allocate enough memory in CUDA for OpenGL interop.");
}
}

2
vtkm/interop/testing/CMakeLists.txt
View File

@ -53,5 +53,5 @@ endif()
vtkm_declare_headers(${headers})
vtkm_unit_tests(SOURCES ${unit_tests})
if(needs_rendering)
target_link_libraries(UnitTests_vtkm_interop_testing vtkm_rendering)
target_link_libraries(UnitTests_vtkm_interop_testing PRIVATE vtkm_rendering)
endif()

8
vtkm/interop/testing/TestingOpenGLInterop.h
View File

@ -77,13 +77,13 @@ private:
vtkm::interop::BufferState state(handle);
vtkm::interop::TransferToOpenGL(array, state, DeviceAdapterTag());
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
std::cout << error.GetMessage() << std::endl;
VTKM_TEST_ASSERT(true==false,
"Got an unexpected Out Of Memory error transferring to openGL");
}
catch (vtkm::cont::ErrorControlBadValue bvError)
catch (vtkm::cont::ErrorBadValue bvError)
{
std::cout << bvError.GetMessage() << std::endl;
VTKM_TEST_ASSERT(true==false,
@ -100,13 +100,13 @@ private:
vtkm::interop::BufferState state(handle, type);
vtkm::interop::TransferToOpenGL(array, state, DeviceAdapterTag());
}
catch (vtkm::cont::ErrorControlBadAllocation error)
catch (vtkm::cont::ErrorBadAllocation error)
{
std::cout << error.GetMessage() << std::endl;
VTKM_TEST_ASSERT(true==false,
"Got an unexpected Out Of Memory error transferring to openGL");
}
catch (vtkm::cont::ErrorControlBadValue bvError)
catch (vtkm::cont::ErrorBadValue bvError)
{
std::cout << bvError.GetMessage() << std::endl;
VTKM_TEST_ASSERT(true==false,

10
vtkm/io/writer/VTKDataSetWriter.h
View File

@ -26,8 +26,8 @@
#include <vtkm/cont/CellSetStructured.h>
#include <vtkm/cont/CellSetSingleType.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadType.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Field.h>
#include <vtkm/io/ErrorIO.h>
@ -371,7 +371,7 @@ private:
}
else
{
throw vtkm::cont::ErrorControlBadType(
throw vtkm::cont::ErrorBadType(
"Could not determine type to write out.");
}
@ -399,14 +399,14 @@ public:
}
else
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Selected invalid cell set index.");
}
}
if (dataSet.GetNumberOfCoordinateSystems() < 1)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"DataSet has no coordinate system, which is not supported by VTK file format.");
}

2
vtkm/rendering/AxisAnnotation.cxx
View File

@ -20,7 +20,7 @@
#include <vtkm/rendering/AxisAnnotation.h>
#include <vtkm/cont/ErrorControlBadType.h>
#include <vtkm/cont/ErrorBadType.h>
namespace vtkm {
namespace rendering {

10
vtkm/rendering/CMakeLists.txt
View File

@ -156,6 +156,16 @@ else()
)
endif()
target_link_libraries(vtkm_rendering
PUBLIC vtkm_cont
PRIVATE ${VTKm_OPENGL_LIBRARIES}
${VTKm_BACKEND_LIBRARIES}
)
target_include_directories(vtkm_rendering
PRIVATE ${VTKm_OPENGL_INCLUDE_DIRS}
${VTKm_BACKEND_INCLUDE_DIRS}
)
# Subclasses need rendering library
vtkm_configure_component_Rendering()

12
vtkm/rendering/CanvasEGL.cxx
View File

@ -60,12 +60,12 @@ void CanvasEGL::Initialize()
this->Internals->Display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (!(this->Internals->Display))
{
throw vtkm::cont::ErrorControlBadValue("Failed to get EGL display");
throw vtkm::cont::ErrorBadValue("Failed to get EGL display");
}
EGLint major, minor;
if (!(eglInitialize(this->Internals->Display, &major, &minor)))
{
throw vtkm::cont::ErrorControlBadValue("Failed to initialize EGL display");
throw vtkm::cont::ErrorBadValue("Failed to initialize EGL display");
}
const EGLint cfgAttrs[] =
@ -84,7 +84,7 @@ void CanvasEGL::Initialize()
if (!(eglChooseConfig(this->Internals->Display, cfgAttrs, &cfg, 1, &nCfgs)) ||
(nCfgs == 0))
{
throw vtkm::cont::ErrorControlBadValue("Failed to get EGL config");
throw vtkm::cont::ErrorBadValue("Failed to get EGL config");
}
const EGLint pbAttrs[] =
@ -98,21 +98,21 @@ void CanvasEGL::Initialize()
eglCreatePbufferSurface(this->Internals->Display, cfg, pbAttrs);
if (!this->Internals->Surface)
{
throw vtkm::cont::ErrorControlBadValue("Failed to create EGL PBuffer surface");
throw vtkm::cont::ErrorBadValue("Failed to create EGL PBuffer surface");
}
eglBindAPI(EGL_OPENGL_API);
this->Internals->Context =
eglCreateContext(this->Internals->Display, cfg, EGL_NO_CONTEXT, NULL);
if (!this->Internals->Context)
{
throw vtkm::cont::ErrorControlBadValue("Failed to create EGL context");
throw vtkm::cont::ErrorBadValue("Failed to create EGL context");
}
if (!(eglMakeCurrent(this->Internals->Display,
this->Internals->Surface,
this->Internals->Surface,
this->Internals->Context)))
{
throw vtkm::cont::ErrorControlBadValue("Failed to create EGL context current");
throw vtkm::cont::ErrorBadValue("Failed to create EGL context current");
}
}

6
vtkm/rendering/CanvasOSMesa.cxx
View File

@ -68,7 +68,7 @@ void CanvasOSMesa::Initialize()
if (!this->Internals->Context)
{
throw vtkm::cont::ErrorControlBadValue("OSMesa context creation failed.");
throw vtkm::cont::ErrorBadValue("OSMesa context creation failed.");
}
vtkm::Vec<vtkm::Float32,4> *colorBuffer =
this->GetColorBuffer().GetStorage().GetArray();
@ -78,7 +78,7 @@ void CanvasOSMesa::Initialize()
static_cast<GLsizei>(this->GetWidth()),
static_cast<GLsizei>(this->GetHeight())))
{
throw vtkm::cont::ErrorControlBadValue("OSMesa context activation failed.");
throw vtkm::cont::ErrorBadValue("OSMesa context activation failed.");
}
@ -110,7 +110,7 @@ void CanvasOSMesa::Finish()
static_cast<vtkm::Id>(w)!=this->GetWidth() ||
static_cast<vtkm::Id>(h)!=this->GetHeight())
{
throw vtkm::cont::ErrorControlBadValue("Wrong width/height in ZBuffer");
throw vtkm::cont::ErrorBadValue("Wrong width/height in ZBuffer");
}
vtkm::cont::ArrayHandle<vtkm::Float32>::PortalControl depthPortal =
this->GetDepthBuffer().GetPortalControl();

8
vtkm/rendering/MapperGL.cxx
View File

@ -310,7 +310,7 @@ void RenderTriangles(MapperGL &mapper,
msg = std::string(strInfoLog);
delete [] strInfoLog;
}
throw vtkm::cont::ErrorControlBadValue("Shader compile error:"+msg);
throw vtkm::cont::ErrorBadValue("Shader compile error:"+msg);
}
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
@ -333,7 +333,7 @@ void RenderTriangles(MapperGL &mapper,
msg = std::string(strInfoLog);
delete [] strInfoLog;
}
throw vtkm::cont::ErrorControlBadValue("Shader compile error:"+msg);
throw vtkm::cont::ErrorBadValue("Shader compile error:"+msg);
}
mapper.shader_programme = glCreateProgram();
@ -353,7 +353,7 @@ void RenderTriangles(MapperGL &mapper,
GLsizei len;
glGetProgramInfoLog(mapper.shader_programme, 2048, &len, log);
std::string msg = std::string("Shader program link failed: ")+std::string(log);
throw vtkm::cont::ErrorControlBadValue(msg);
throw vtkm::cont::ErrorBadValue(msg);
}
}
}
@ -471,7 +471,7 @@ void MapperGL::SetCanvas(vtkm::rendering::Canvas *c)
{
this->Canvas = dynamic_cast<vtkm::rendering::CanvasGL*>(c);
if (this->Canvas == NULL)
throw vtkm::cont::ErrorControlBadValue("Bad canvas type for MapperGL. Must be CanvasGL");
throw vtkm::cont::ErrorBadValue("Bad canvas type for MapperGL. Must be CanvasGL");
}
}

2
vtkm/rendering/MapperRayTracer.cxx
View File

@ -90,7 +90,7 @@ void MapperRayTracer::SetCanvas(vtkm::rendering::Canvas *canvas)
this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Internals->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Ray Tracer: bad canvas type. Must be CanvasRayTracer");
}
}

2
vtkm/rendering/MapperVolume.cxx
View File

@ -96,7 +96,7 @@ void MapperVolume::SetCanvas(vtkm::rendering::Canvas *canvas)
this->Internals->Canvas = dynamic_cast<CanvasRayTracer*>(canvas);
if(this->Internals->Canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Ray Tracer: bad canvas type. Must be CanvasRayTracer");
}
}

4
vtkm/rendering/Triangulator.h
View File

@ -553,12 +553,12 @@ public:
}
else
{
throw vtkm::cont::ErrorControlBadType("Unsupported cell type for trianglulation with CellSetSingleType");
throw vtkm::cont::ErrorBadType("Unsupported cell type for trianglulation with CellSetSingleType");
}
}
else
{
throw vtkm::cont::ErrorControlBadType("Unsupported cell set type for trianglulation");
throw vtkm::cont::ErrorBadType("Unsupported cell set type for trianglulation");
}
//get rid of any triagles we cannot see

16
vtkm/rendering/raytracing/Camera.h
View File

@ -21,7 +21,7 @@
#define vtk_m_rendering_raytracing_Camera_h
#include <vtkm/VectorAnalysis.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/rendering/Camera.h>
#include <vtkm/rendering/CanvasRayTracer.h>
#include <vtkm/rendering/raytracing/Ray.h>
@ -259,7 +259,7 @@ public:
{
if(height <= 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera height must be greater than zero.");
}
if(Height != height)
@ -281,7 +281,7 @@ public:
{
if(width <= 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera width must be greater than zero.");
}
if(this->Width != width)
@ -303,7 +303,7 @@ public:
{
if(zoom <= 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera zoom must be greater than zero.");
}
if(this->Zoom != zoom)
@ -324,12 +324,12 @@ public:
{
if(degrees <= 0)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera feild of view must be greater than zero.");
}
if(degrees > 180)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera feild of view must be less than 180.");
}
// fov is stored as a half angle
@ -421,13 +421,13 @@ public:
{
if(canvas == nullptr)
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Camera can not write to nullptr canvas");
}
if(this->Height != vtkm::Int32(canvas->GetHeight()) ||
this->Width != vtkm::Int32(canvas->GetWidth()))
{
throw vtkm::cont::ErrorControlBadValue("Camera: suface-view mismatched dims");
throw vtkm::cont::ErrorBadValue("Camera: suface-view mismatched dims");
}
vtkm::worklet::DispatcherMapField< SurfaceConverter >(
SurfaceConverter( this->Width,

2
vtkm/rendering/raytracing/RayTracer.h
View File

@ -239,7 +239,7 @@ public:
{
bool isSupportedField = (scalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
scalarField->GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET );
if(!isSupportedField) throw vtkm::cont::ErrorControlBadValue("Feild not accociated with cell set or points");
if(!isSupportedField) throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
bool isAssocPoints = scalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
vtkm::worklet::DispatcherMapField< CalculateNormals >( CalculateNormals(bvh.LeafNodes) )

6
vtkm/rendering/raytracing/VolumeRendererStructured.h
View File

@ -26,7 +26,7 @@
#include <iostream>
#include <stdio.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/rendering/ColorTable.h>
#include <vtkm/rendering/raytracing/Ray.h>
#include <vtkm/rendering/raytracing/Camera.h>
@ -1000,7 +1000,7 @@ class SamplerCellAssocRect : public vtkm::worklet::WorkletMapField
Rays.MaxDistance);
bool isSupportedField = (ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS ||
ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET );
if(!isSupportedField) throw vtkm::cont::ErrorControlBadValue("Feild not accociated with cell set or points");
if(!isSupportedField) throw vtkm::cont::ErrorBadValue("Field not accociated with cell set or points");
bool isAssocPoints = ScalarField->GetAssociation() == vtkm::cont::Field::ASSOC_POINTS;
if(IsUniformDataSet)
{
@ -1086,7 +1086,7 @@ class SamplerCellAssocRect : public vtkm::worklet::WorkletMapField
void SetSampleDistance(const vtkm::Float32 & distance)
{
if(distance <= 0.f)
throw vtkm::cont::ErrorControlBadValue("Sample distance must be positive.");
throw vtkm::cont::ErrorBadValue("Sample distance must be positive.");
SampleDistance = distance;
}

2
vtkm/worklet/Keys.h
View File

@ -365,7 +365,7 @@ struct Transport<
{
if (object.GetNumberOfValues() != inputDomain.GetInputRange())
{
throw vtkm::cont::ErrorControlBadValue(
throw vtkm::cont::ErrorBadValue(
"Input array to worklet invocation the wrong size.");
}

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