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' of https://gitlab.kitware.com/vtk/vtk-m into gridEval

Browse Source
This commit is contained in:
Dave Pugmire 2019-02-18 14:38:37 -05:00
commit 314ebd3dc6
215 changed files with 3196 additions and 1447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMake/VTKmCheckCopyright.cmake
View File

@ -234,7 +234,6 @@ foreach (glob_expression ${FILES_TO_CHECK})
endforeach(exception)
if (NOT skip)
message("Checking ${file}")
check_copyright("${VTKm_SOURCE_DIR}/${file}")
endif (NOT skip)
endforeach (file)

116
CMake/VTKmCheckSourceInBuild.cmake
View File

@ -1,116 +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 2016 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
## Copyright 2016 UT-Battelle, LLC.
## Copyright 2016 Los Alamos National Security.
##
## Under the terms of Contract DE-NA0003525 with NTESS,
## the U.S. Government retains certain rights in this software.
##
## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
## Laboratory (LANL), the U.S. Government retains certain rights in
## this software.
##============================================================================
## This CMake script checks to make sure that each source file is explicitly
## listed in the CMakeLists.txt files. This helps ensure that all files that we
## are using are appropriately listed in IDEs and installed as necessary. It
## also helps identify dead files that should no longer be in the repository.
## To run this script, execute CMake as follows:
##
## cmake -DVTKm_SOURCE_DIR=<VTKm_SOURCE_DIR> -P <VTKm_SOURCE_DIR>/CMake/VTKMCheckSourceInBuild.cmake
##
set(FILES_TO_CHECK
*.h
*.h.in
*.cxx
*.cu
)
set(EXCEPTIONS
kxsort.h
)
set(DIRECTORY_EXCEPTIONS
${VTKm_SOURCE_DIR}/vtkm/thirdparty/taotuple/vtkmtaotuple
${VTKm_SOURCE_DIR}/vtkm/thirdparty/diy/vtkmdiy
)
if (NOT VTKm_SOURCE_DIR)
message(SEND_ERROR "VTKm_SOURCE_DIR not defined.")
endif (NOT VTKm_SOURCE_DIR)
function(check_directory directory parent_CMakeLists_contents)
foreach(exception IN LISTS DIRECTORY_EXCEPTIONS)
if(directory MATCHES "^${exception}$")
return()
endif()
endforeach(exception)
message("Checking directory ${directory}...")
get_filename_component(directory_name "${directory}" NAME)
if(EXISTS "${directory}/CMakeLists.txt")
file(READ "${directory}/CMakeLists.txt" CMakeLists_contents)
endif()
foreach (glob_expression ${FILES_TO_CHECK})
file(GLOB file_list
RELATIVE "${directory}"
"${directory}/${glob_expression}"
)
foreach (file ${file_list})
set(skip)
foreach(exception ${EXCEPTIONS})
if(file MATCHES "^${exception}(/.*)?$")
# This file is an exception
set(skip TRUE)
endif()
endforeach(exception)
if(NOT skip)
message("Checking ${file}")
# Remove .in suffix. These are generally configured files that generate
# new files that are actually used in the build.
string(REGEX REPLACE ".in$" "" file_check "${file}")
string(FIND "${CMakeLists_contents}" "${file_check}" position)
if(${position} LESS 0)
# Check the CMakeLists.txt of the parent directory. Some sources of
# internal directories are packaged into libraries in the parent
# directory.
string(FIND "${parent_CMakeLists_contents}"
"${directory_name}/${file_check}"
position
)
if(${position} LESS 0)
message(SEND_ERROR
"****************************************************************
${file_check} is not found in ${directory}/CMakeLists.txt
This indicates that the file is not part of the build system. Thus it might be missing build targets. All such files should be explicitly handled by CMake.")
endif() # Not in parent's CMakeLists.txt
endif() # Not in CMakeLists.txt
endif() # Not skipped
endforeach (file)
endforeach(glob_expression)
file(GLOB file_list
LIST_DIRECTORIES true
"${directory}/*")
foreach(file ${file_list})
if(IS_DIRECTORY "${file}")
check_directory("${file}" "${CMakeLists_contents}")
endif()
endforeach(file)
endfunction(check_directory)
check_directory("${VTKm_SOURCE_DIR}/vtkm" "")
check_directory("${VTKm_SOURCE_DIR}/examples" "")

172
CMake/VTKmCheckSourceInInstall.cmake Normal file
View File

@ -0,0 +1,172 @@
##============================================================================
## 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 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
## Copyright 2016 UT-Battelle, LLC.
## Copyright 2016 Los Alamos National Security.
##
## Under the terms of Contract DE-NA0003525 with NTESS,
## the U.S. Government retains certain rights in this software.
##
## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
## Laboratory (LANL), the U.S. Government retains certain rights in
## this software.
##============================================================================
## This CMake script checks to make sure that each source file explicitly
## inside a project is installed.
## To run this script, execute CMake as follows:
##
## cmake -DMODE=[INSTALL|VERIFY|CLEANUP]
# -DVTKm_SOURCE_DIR=<VTKm_SOURCE_DIR>
# -DVTKm_BINARY_DIR=<VTKm_BINARY_DIR>
# -DVTKm_INSTALL_INCLUDE_DIR=<VTKm_INSTALL_INCLUDE_DIR>
# -DVTKm_ENABLE_RENDERING=<VTKm_ENABLE_RENDERING>
# -DVTKm_ENABLE_LOGGING=<VTKm_ENABLE_LOGGING>
# -P <VTKm_SOURCE_DIR>/CMake/VTKMCheckSourceInInstall.cmake
##
if (NOT DEFINED MODE)
message(FATAL_ERROR "Need to pass the MODE variable (INSTALL|VERIFY|CLEANUP) so the script knows what to do")
endif ()
if (NOT VTKm_SOURCE_DIR)
message(FATAL_ERROR "VTKm_SOURCE_DIR not defined.")
endif ()
if (NOT VTKm_BINARY_DIR)
message(FATAL_ERROR "VTKm_BINARY_DIR not defined.")
endif ()
if (NOT VTKm_INSTALL_INCLUDE_DIR)
message(FATAL_ERROR "VTKm_INSTALL_INCLUDE_DIR not defined.")
endif ()
if (NOT DEFINED VTKm_ENABLE_RENDERING)
message(FATAL_ERROR "VTKm_ENABLE_RENDERING not defined.")
endif ()
if (NOT DEFINED VTKm_ENABLE_LOGGING)
message(FATAL_ERROR "VTKm_ENABLE_LOGGING not defined.")
endif ()
include(CMakeParseArguments)
# -----------------------------------------------------------------------------
function(verify_install_per_dir src_directory build_dir)
set(options )
set(oneValueArgs )
set(multiValueArgs EXTENSIONS FILE_EXCEPTIONS DIR_EXCEPTIONS)
cmake_parse_arguments(verify
"${options}" "${oneValueArgs}" "${multiValueArgs}"
${ARGN}
)
set(files_to_verify )
foreach(ext IN LISTS verify_EXTENSIONS)
file(GLOB_RECURSE listing
RELATIVE "${src_directory}"
"${src_directory}/${ext}"
)
list(APPEND files_to_verify ${listing})
endforeach()
#remove all files that are exempt
list(REMOVE_ITEM files_to_verify ${verify_FILE_EXCEPTIONS})
#remove all files inside directories that match
foreach(dir IN LISTS verify_DIR_EXCEPTIONS)
list(FILTER files_to_verify EXCLUDE REGEX "^${dir}")
endforeach()
set(to_fail FALSE) # error out after listing all missing headers
foreach(file IN LISTS files_to_verify)
if(NOT EXISTS ${build_dir}/${file})
message(STATUS "file: ${file} not installed \n\tWas expecting it to be at: ${build_dir}/${file}")
set(to_fail TRUE)
# else()
# message(STATUS "file: ${file} installed")
endif()
endforeach()
if(to_fail)
message(FATAL_ERROR "unable to find all headers in the install tree")
endif()
endfunction()
# -----------------------------------------------------------------------------
function(do_install root_dir prefix)
#Step 1. Setup up our new install prefix location
set(CMAKE_INSTALL_PREFIX ${root_dir}/${prefix})
#Step 2. Gather all the cmake_install.cmake files
file(GLOB_RECURSE install_files
LIST_DIRECTORIES False
RELATIVE "${root_dir}"
"${root_dir}/*/cmake_install.cmake")
#Step 3. Execute all the install files
if(EXISTS "${root_dir}/cmake_install.cmake")
include(${root_dir}/cmake_install.cmake)
endif()
foreach(file ${install_files})
include("${file}")
endforeach()
endfunction()
# -----------------------------------------------------------------------------
function(do_verify root_dir prefix)
#Step 1. Setup the extensions to check, and all file and directory
# extensions
set(files_extensions
*.hpp #needed for diy and taotuple
*.h
*.hxx
)
set(file_exceptions
cont/ColorTablePrivate.hxx
)
#by default every header in a testing directory doesn't need to be installed
set(directory_exceptions ".*/testing" )
# These exceptions should be based on the status of the associated
# cmake option
if(NOT VTKm_ENABLE_RENDERING)
list(APPEND directory_exceptions rendering)
endif()
if(NOT VTKm_ENABLE_LOGGING)
list(APPEND directory_exceptions thirdparty/loguru)
endif()
#Step 2. Verify the installed files match what headers are listed in each
# source directory
verify_install_per_dir("${VTKm_SOURCE_DIR}/vtkm"
"${root_dir}/${prefix}/${VTKm_INSTALL_INCLUDE_DIR}/vtkm"
EXTENSIONS ${files_extensions}
FILE_EXCEPTIONS ${file_exceptions}
DIR_EXCEPTIONS ${directory_exceptions}
)
endfunction()
# -----------------------------------------------------------------------------
function(do_cleanup root_dir prefix)
#Step 1. Remove temp directory
file(REMOVE_RECURSE "${root_dir}/${prefix}")
endfunction()
set(root_dir "${VTKm_BINARY_DIR}")
set(prefix "/CMakeFiles/_tmp_install")
message(STATUS "MODE: ${MODE}")
if(MODE STREQUAL "INSTALL")
do_install(${root_dir} ${prefix})
elseif(MODE STREQUAL "VERIFY")
do_verify(${root_dir} ${prefix})
elseif(MODE STREQUAL "CLEANUP")
do_cleanup(${root_dir} ${prefix})
endif()
unset(prefix)
unset(root_dir)

15
CMake/VTKmWrappers.cmake
View File

@ -149,16 +149,8 @@ endfunction(vtkm_install_headers)
#-----------------------------------------------------------------------------
function(vtkm_declare_headers)
set(options CUDA)
set(oneValueArgs)
set(multiValueArgs)
cmake_parse_arguments(VTKm_DH "${options}"
"${oneValueArgs}" "${multiValueArgs}"
${ARGN}
)
vtkm_get_kit_name(name dir_prefix)
vtkm_install_headers("${dir_prefix}" ${hfiles})
vtkm_install_headers("${dir_prefix}" ${ARGN})
endfunction(vtkm_declare_headers)
#-----------------------------------------------------------------------------
@ -254,10 +246,9 @@ function(vtkm_library)
#generate the export header and install it
vtkm_generate_export_header(${lib_name})
#test and install the headers
#install the headers
vtkm_declare_headers(${VTKm_LIB_HEADERS}
EXCLUDE_FROM_TESTING ${VTKm_LIB_TEMPLATE_SOURCES}
)
${VTKm_LIB_TEMPLATE_SOURCES})
# When building libraries/tests that are part of the VTK-m repository inherit
# the properties from vtkm_developer_flags. The flags are intended only for

77
CMakeLists.txt
View File

@ -152,9 +152,6 @@ include(VTKmWrappers)
include(VTKmCompilerFlags)
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
if (VTKm_ENABLE_TESTING)
enable_testing()
@ -171,24 +168,6 @@ if (VTKm_ENABLE_TESTING)
configure_file(${VTKm_SOURCE_DIR}/CTestCustom.cmake.in
${VTKm_BINARY_DIR}/CTestCustom.cmake @ONLY)
#-----------------------------------------------------------------------------
# Add "meta" tests that check the state of the repository
# SystemInformation prints out information about the current configuration
# CopyrightStatement checks that the copyright statement is in all source files
# SourceInBuild checks that all source files are listed in the build
add_test(NAME SystemInformation
COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" "-DVTKm_BINARY_DIR=${VTKm_BINARY_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmSystemInformation.cmake"
)
add_test(NAME CopyrightStatement
COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckCopyright.cmake"
)
# increase timeout since on some machines CopyrightStatement test takes a long time.
set_tests_properties(CopyrightStatement PROPERTIES TIMEOUT 300)
add_test(NAME SourceInBuild
COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckSourceInBuild.cmake"
)
#-----------------------------------------------------------------------------
# Find the Python interpreter, which we will use during the build process
find_package(PythonInterp QUIET)
@ -325,3 +304,59 @@ endif()
if(VTKm_ENABLE_EXAMPLES)
add_subdirectory(examples)
endif(VTKm_ENABLE_EXAMPLES)
#-----------------------------------------------------------------------------
if (VTKm_ENABLE_TESTING)
#-----------------------------------------------------------------------------
# Add "meta" tests that check the state of the repository
# SystemInformation prints out information about the current configuration
# CopyrightStatement checks that the copyright statement is in all source files
# SourceInBuild checks that all source files are listed in the build
# SourceInInstall checks that all source files are installed in the build
add_test(NAME SystemInformation
COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" "-DVTKm_BINARY_DIR=${VTKm_BINARY_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmSystemInformation.cmake"
)
add_test(NAME CopyrightStatement
COMMAND ${CMAKE_COMMAND} "-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}" -P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckCopyright.cmake"
)
# increase timeout since on some machines CopyrightStatement test takes a long time.
set_tests_properties(CopyrightStatement PROPERTIES TIMEOUT 300)
if(NOT VTKm_INSTALL_ONLY_LIBRARIES)
set(command_args
"-DVTKm_SOURCE_DIR=${VTKm_SOURCE_DIR}"
"-DVTKm_BINARY_DIR=${VTKm_BINARY_DIR}"
"-DVTKm_INSTALL_INCLUDE_DIR=${VTKm_INSTALL_INCLUDE_DIR}"
"-DVTKm_ENABLE_RENDERING=${VTKm_ENABLE_RENDERING}"
"-DVTKm_ENABLE_LOGGING=${VTKm_ENABLE_LOGGING}"
)
#By having this as separate tests using fixtures, it will allow us in
#the future to write tests that build against the installed version
add_test(NAME TestInstallSetup
COMMAND ${CMAKE_COMMAND}
"-DMODE=INSTALL"
${command_args}
-P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckSourceInInstall.cmake"
)
add_test(NAME SourceInInstall
COMMAND ${CMAKE_COMMAND}
"-DMODE=VERIFY"
${command_args}
-P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckSourceInInstall.cmake"
)
add_test(NAME TestInstallCleanup
COMMAND ${CMAKE_COMMAND}
"-DMODE=CLEANUP"
${command_args}
-P "${VTKm_SOURCE_DIR}/CMake/VTKmCheckSourceInInstall.cmake"
)
set_tests_properties(TestInstallSetup PROPERTIES FIXTURES_SETUP vtkm_installed)
set_tests_properties(SourceInInstall PROPERTIES FIXTURES_REQUIRED vtkm_installed)
set_tests_properties(TestInstallCleanup PROPERTIES FIXTURES_CLEANUP vtkm_installed)
endif()
endif()

3
CTestCustom.cmake.in
View File

@ -37,6 +37,9 @@ list(APPEND CTEST_CUSTOM_WARNING_EXCEPTION
"CONTRIBUTING.md.*warning"
"CodingConventions.md.*warning"
# disable static/dynamic weak symbol warnings
".*ld: warning: direct access in function.*"
# disable PTX warning about recursive functions. These look like they can't be silenced
# without disabling all PTX warnings, show hide them on the dashboard.

1
LICENSE.txt
View File

@ -77,6 +77,7 @@ vtkm/cont/tbb/internal/parallel_sort.h
vtkm/cont/tbb/internal/parallel_radix_sort_tbb.h
vtkm/cont/tbb/internal/kxsort.h
vtkm/testing/OptionParser.h
vtkm/thirdparty
vtkm/internal/brigand.hpp
version.txt

3
Utilities/DynamicAnalysis/lsan.supp
View File

@ -1 +1,4 @@
leak:libX11*
leak:loguru.hpp
leak:/usr/lib/x86_64-linux-gnu/openmp*
leak:/usr/lib/x86_64-linux-gnu/libopen-pal*

27
benchmarking/BenchmarkArrayTransfer.cxx
View File

@ -45,7 +45,7 @@ struct BenchmarkArrayTransfer
{
using Algo = vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter>;
using StorageTag = vtkm::cont::StorageTagBasic;
using Timer = vtkm::cont::Timer<DeviceAdapter>;
using Timer = vtkm::cont::Timer;
//------------- Functors for benchmarks --------------------------------------
@ -171,7 +171,8 @@ struct BenchmarkArrayTransfer
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
ReadValues<PortalType> functor(array.PrepareForInput(DeviceAdapter()),
ValueTypeTraits::ZeroInitialization());
Algo::Schedule(functor, this->NumValues);
@ -212,9 +213,11 @@ struct BenchmarkArrayTransfer
ArrayType array;
// Time the write:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
WriteValues<PortalType> functor(array.PrepareForOutput(this->NumValues, DeviceAdapter()));
Algo::Schedule(functor, this->NumValues);
return timer.GetElapsedTime();
}
};
@ -254,7 +257,8 @@ struct BenchmarkArrayTransfer
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
ReadWriteValues<PortalType> functor(array.PrepareForInPlace(DeviceAdapter()));
Algo::Schedule(functor, this->NumValues);
return timer.GetElapsedTime();
@ -301,7 +305,8 @@ struct BenchmarkArrayTransfer
array.ReleaseResourcesExecution();
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
// Copy to device:
ReadValues<PortalExecType> functor(array.PrepareForInput(DeviceAdapter()),
@ -360,7 +365,8 @@ struct BenchmarkArrayTransfer
array.ReleaseResourcesExecution();
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
// Do work on device:
ReadWriteValues<PortalExecType> functor(array.PrepareForInPlace(DeviceAdapter()));
@ -411,7 +417,8 @@ struct BenchmarkArrayTransfer
ArrayType array;
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
// Allocate/write data on device
WriteValues<PortalExecType> functor(array.PrepareForOutput(this->NumValues, DeviceAdapter()));
@ -464,7 +471,8 @@ struct BenchmarkArrayTransfer
ArrayType array;
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
// Allocate/write data on device
WriteValues<PortalExecType> functor(array.PrepareForOutput(this->NumValues, DeviceAdapter()));
@ -516,7 +524,8 @@ struct BenchmarkArrayTransfer
ArrayType array;
// Time the copy:
Timer timer;
Timer timer{ DeviceAdapter() };
timer.Start();
// Allocate/write data on device
WriteValues<PortalExecType> functor(array.PrepareForOutput(this->NumValues, DeviceAdapter()));

33
benchmarking/BenchmarkAtomicArray.cxx
View File

@ -62,7 +62,7 @@ class BenchmarkAtomicArray
{
public:
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
using Timer = vtkm::cont::Timer<Device>;
using Timer = vtkm::cont::Timer;
// Benchmarks AtomicArray::Add such that each work index writes to adjacent
// indices.
@ -102,8 +102,10 @@ public:
auto portal = array.PrepareForExecution(Device{});
Worker<decltype(portal)> worker{ this->ArraySize, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -156,8 +158,10 @@ public:
auto portal = this->Data.PrepareForOutput(this->ArraySize, Device{});
Worker<decltype(portal)> worker{ this->ArraySize, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -217,8 +221,10 @@ public:
auto portal = array.PrepareForExecution(Device{});
Worker<decltype(portal)> worker{ this->ArraySize, this->Stride, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -276,8 +282,10 @@ public:
auto portal = this->Data.PrepareForOutput(this->ArraySize, Device{});
Worker<decltype(portal)> worker{ this->ArraySize, this->Stride, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -342,8 +350,10 @@ public:
auto portal = array.PrepareForExecution(Device{});
Worker<decltype(portal)> worker{ this->ArraySize, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -398,7 +408,8 @@ public:
auto portal = this->Data.PrepareForOutput(this->ArraySize, Device{});
Worker<decltype(portal)> worker{ this->ArraySize, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -468,8 +479,10 @@ public:
auto portal = array.PrepareForExecution(Device{});
Worker<decltype(portal)> worker{ this->ArraySize, this->Stride, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}
@ -529,8 +542,10 @@ public:
auto portal = this->Data.PrepareForOutput(this->ArraySize, Device{});
Worker<decltype(portal)> worker{ this->ArraySize, this->Stride, portal };
Timer timer;
Timer timer{ Device() };
timer.Start();
Algo::Schedule(worker, NumWrites);
return timer.GetElapsedTime();
}

4
benchmarking/BenchmarkCopySpeeds.cxx
View File

@ -74,8 +74,10 @@ struct MeasureCopySpeed
VTKM_CONT vtkm::Float64 operator()()
{
vtkm::cont::Timer<DeviceAdapter> timer;
vtkm::cont::Timer timer{ DeviceAdapter() };
timer.Start();
Algo::Copy(this->Source, this->Destination);
return timer.GetElapsedTime();
}

44
benchmarking/BenchmarkDeviceAdapter.cxx
View File

@ -177,7 +177,7 @@ class BenchmarkDeviceAdapter
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag>;
using Timer = vtkm::cont::Timer<DeviceAdapterTag>;
using Timer = vtkm::cont::Timer;
public:
// Various kernels used by the different benchmarks to accelerate
@ -284,8 +284,10 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::Copy(ValueHandle_src, ValueHandle_dst);
return timer.GetElapsedTime();
}
@ -331,8 +333,10 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::CopyIf(ValueHandle, StencilHandle, OutHandle);
return timer.GetElapsedTime();
}
@ -388,8 +392,10 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::LowerBounds(InputHandle, ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
@ -442,7 +448,8 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Value tmp = Algorithm::Reduce(InputHandle, vtkm::TypeTraits<Value>::ZeroInitialization());
vtkm::Float64 time = timer.GetElapsedTime();
if (tmp != this->Result)
@ -494,7 +501,8 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::ReduceByKey(KeyHandle, ValueHandle, KeysOut, ValuesOut, vtkm::Add());
return timer.GetElapsedTime();
}
@ -542,7 +550,8 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::ScanInclusive(ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
@ -580,7 +589,8 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::ScanExclusive(ValueHandle, OutHandle);
return timer.GetElapsedTime();
}
@ -624,7 +634,8 @@ private:
ValueArrayHandle array;
Algorithm::Copy(this->ValueHandle, array);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::Sort(array);
return timer.GetElapsedTime();
}
@ -679,7 +690,8 @@ private:
Algorithm::Copy(this->KeyHandle, keys);
Algorithm::Copy(this->ValueHandle, values);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::SortByKey(keys, values);
return timer.GetElapsedTime();
}
@ -737,7 +749,8 @@ private:
vtkm::cont::ArrayHandle<vtkm::Id> indices;
Algorithm::Copy(vtkm::cont::ArrayHandleIndex(arraySize), indices);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
SSI::Sort(ValueHandle, indices);
return timer.GetElapsedTime();
}
@ -786,7 +799,8 @@ private:
{
IndexArrayHandle indices;
Algorithm::Copy(this->IndexHandle, indices);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
SSI::Unique(this->ValueHandle, indices);
return timer.GetElapsedTime();
}
@ -843,7 +857,8 @@ private:
ValueArrayHandle array;
Algorithm::Copy(this->ValueHandle, array);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Algorithm::Unique(array);
return timer.GetElapsedTime();
}
@ -900,7 +915,8 @@ private:
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
vtkm::cont::Timer timer;
timer.Start();
Algorithm::UpperBounds(InputHandle, ValueHandle, OutHandle);
return timer.GetElapsedTime();
}

46
benchmarking/BenchmarkFieldAlgorithms.cxx
View File

@ -316,7 +316,7 @@ class BenchmarkFieldAlgorithms
{
using StorageTag = vtkm::cont::StorageTagBasic;
using Timer = vtkm::cont::Timer<DeviceAdapterTag>;
using Timer = vtkm::cont::Timer;
using ValueVariantHandle = vtkm::cont::VariantArrayHandleBase<ValueTypes>;
using InterpVariantHandle = vtkm::cont::VariantArrayHandleBase<InterpValueTypes>;
@ -366,7 +366,8 @@ private:
const Value RISKFREE = 0.02f;
const Value VOLATILITY = 0.30f;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
BlackScholes<Value> worklet(RISKFREE, VOLATILITY);
vtkm::worklet::DispatcherMapField<BlackScholes<Value>> dispatcher(worklet);
dispatcher.SetDevice(DeviceAdapterTag());
@ -405,7 +406,8 @@ private:
const Value RISKFREE = 0.02f;
const Value VOLATILITY = 0.30f;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
BlackScholes<Value> worklet(RISKFREE, VOLATILITY);
vtkm::worklet::DispatcherMapField<BlackScholes<Value>> dispatcher(worklet);
dispatcher.SetDevice(DeviceAdapterTag());
@ -448,7 +450,8 @@ private:
vtkm::cont::ArrayHandle<Value> tempHandle1;
vtkm::cont::ArrayHandle<Value> tempHandle2;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::Invoker invoke(DeviceAdapterTag{});
invoke(Mag{}, this->InputHandle, tempHandle1);
@ -487,7 +490,8 @@ private:
ValueVariantHandle dtemp1(temp1);
ValueVariantHandle dtemp2(temp2);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::Invoker invoke(DeviceAdapterTag{});
invoke(Mag{}, dinput, dtemp1);
@ -530,10 +534,12 @@ private:
{
vtkm::cont::ArrayHandle<Value> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapField<FusedMath> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->InputHandle, result);
return timer.GetElapsedTime();
}
@ -563,10 +569,12 @@ private:
vtkm::cont::ArrayHandle<Value, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapField<FusedMath> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(dinput, result);
return timer.GetElapsedTime();
}
@ -633,10 +641,12 @@ private:
{
vtkm::cont::ArrayHandle<Value> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapField<InterpolateField> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->EdgePairHandle, this->WeightHandle, this->FieldHandle, result);
return timer.GetElapsedTime();
}
@ -666,10 +676,12 @@ private:
EdgeIdVariantHandle dedges(this->EdgePairHandle);
vtkm::cont::ArrayHandle<Value> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapField<InterpolateField> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(dedges, dweight, dfield, result);
return timer.GetElapsedTime();
}
@ -731,10 +743,12 @@ private:
static_cast<const vtkm::Sphere*>(handle.PrepareForExecution(DeviceAdapterTag()));
EvalWorklet eval(function);
vtkm::cont::Timer<DeviceAdapterTag> timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
EvalDispatcher dispatcher(eval);
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->Internal.Points, this->Internal.Result);
return timer.GetElapsedTime();
}
@ -767,10 +781,12 @@ private:
auto sphere = vtkm::cont::make_ImplicitFunctionHandle(Internal.Sphere1);
EvalWorklet eval(sphere.PrepareForExecution(DeviceAdapterTag()));
vtkm::cont::Timer<DeviceAdapterTag> timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
EvalDispatcher dispatcher(eval);
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->Internal.Points, this->Internal.Result);
return timer.GetElapsedTime();
}
@ -806,10 +822,12 @@ private:
auto f2 = static_cast<const vtkm::Sphere*>(h2.PrepareForExecution(DeviceAdapterTag()));
EvalWorklet eval(f1, f2);
vtkm::cont::Timer<DeviceAdapterTag> timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
EvalDispatcher dispatcher(eval);
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->Internal.Points, this->Internal.Result);
return timer.GetElapsedTime();
}
@ -845,10 +863,12 @@ private:
EvalWorklet eval(s1.PrepareForExecution(DeviceAdapterTag()),
s2.PrepareForExecution(DeviceAdapterTag()));
vtkm::cont::Timer<DeviceAdapterTag> timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
EvalDispatcher dispatcher(eval);
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->Internal.Points, this->Internal.Result);
return timer.GetElapsedTime();
}

38
benchmarking/BenchmarkFilters.cxx
View File

@ -172,7 +172,7 @@ public:
template <class DeviceAdapterTag>
class BenchmarkFilters
{
using Timer = vtkm::cont::Timer<DeviceAdapterTag>;
using Timer = vtkm::cont::Timer;
enum GradOpts
{
@ -229,7 +229,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -316,7 +317,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -354,7 +356,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -379,7 +382,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -403,7 +407,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -430,7 +435,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -456,7 +462,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -498,7 +505,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -542,7 +550,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -576,7 +585,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -601,7 +611,8 @@ class BenchmarkFilters
VTKM_CONT
vtkm::Float64 operator()()
{
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
this->Filter.Execute(InputDataSet, BenchmarkFilterPolicy());
return timer.GetElapsedTime();
}
@ -650,7 +661,8 @@ class BenchmarkFilters
vtkm::TopologyElementTagPoint{});
}
vtkm::cont::Timer<Device> timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
cellSet.PrepareForInput(
Device{}, vtkm::TopologyElementTagCell{}, vtkm::TopologyElementTagPoint{});
this->Time = timer.GetElapsedTime();

3
benchmarking/BenchmarkRayTracing.cxx
View File

@ -114,7 +114,8 @@ struct BenchRayTracing
VTKM_CONT
vtkm::Float64 operator()()
{
vtkm::cont::Timer<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> timer;
vtkm::cont::Timer timer;
timer.Start();
RayCamera.CreateRays(Rays, Coords.GetBounds());
Tracer.Render(Rays);

21
benchmarking/BenchmarkTopologyAlgorithms.cxx
View File

@ -140,7 +140,7 @@ class BenchmarkTopologyAlgorithms
{
using StorageTag = vtkm::cont::StorageTagBasic;
using Timer = vtkm::cont::Timer<DeviceAdapterTag>;
using Timer = vtkm::cont::Timer;
using ValueVariantHandle = vtkm::cont::VariantArrayHandleBase<ValueTypes>;
@ -205,7 +205,8 @@ private:
cellSet.SetPointDimensions(vtkm::Id3(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE));
vtkm::cont::ArrayHandle<Value, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapTopology<AverageCellToPoint> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
@ -241,7 +242,8 @@ private:
ValueVariantHandle dinput(this->InputHandle);
vtkm::cont::ArrayHandle<Value, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapTopology<AverageCellToPoint> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
@ -284,7 +286,8 @@ private:
cellSet.SetPointDimensions(vtkm::Id3(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE));
vtkm::cont::ArrayHandle<Value, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapTopology<AveragePointToCell> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
@ -320,7 +323,8 @@ private:
ValueVariantHandle dinput(this->InputHandle);
vtkm::cont::ArrayHandle<Value, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
vtkm::worklet::DispatcherMapTopology<AveragePointToCell> dispatcher;
dispatcher.SetDevice(DeviceAdapterTag());
@ -367,7 +371,8 @@ private:
ValueVariantHandle dinput(this->InputHandle);
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Classification<Value> worklet(this->IsoValue);
vtkm::worklet::DispatcherMapTopology<Classification<Value>> dispatcher(worklet);
@ -401,13 +406,15 @@ private:
cellSet.SetPointDimensions(vtkm::Id3(CUBE_SIZE, CUBE_SIZE, CUBE_SIZE));
vtkm::cont::ArrayHandle<vtkm::IdComponent, StorageTag> result;
Timer timer;
Timer timer{ DeviceAdapterTag() };
timer.Start();
Classification<Value> worklet(this->IsoValue);
vtkm::worklet::DispatcherMapTopology<Classification<Value>> dispatcher(worklet);
dispatcher.SetDevice(DeviceAdapterTag());
dispatcher.Invoke(this->InputHandle, cellSet, result);
timer.Stop();
return timer.GetElapsedTime();
}

2
benchmarking/CMakeLists.txt
View File

@ -69,7 +69,7 @@ set(benchmarks
)
foreach (benchmark ${benchmarks})
add_benchmark(${benchmark} ${benchmark}.cxx vtkm_cont)
add_benchmark(${benchmark} ${benchmark}.cxx vtkm_filter)
endforeach ()
if(TARGET vtkm_rendering)

65
docs/changelog/asynchronize-device-independent-timer.md Normal file
View File

@ -0,0 +1,65 @@
# Introduce asynchronous and device independent timer
The timer class now is asynchronous and device independent. it's using an
similiar API as vtkOpenGLRenderTimer with Start(), Stop(), Reset(), Ready(),
and GetElapsedTime() function. For convenience and backward compability, Each
Start() function call will call Reset() internally. GetElapsedTime() function
can be used multiple times to time sequential operations and Stop() function
can be helpful when you want to get the elapsed time latter.
Bascially it can be used in two modes:
* Create a Timer without any device info.
* It would enable the timer for all enabled devices on the machine. Users can get a
specific elapsed time by passing a device id into the GetElapsedTime function.
If no device is provided, it would pick the maximum of all timer results - the
logic behind this decision is that if cuda is disabled, openmp, serial and tbb
roughly give the same results; if cuda is enabled it's safe to return the
maximum elapsed time since users are more interested in the device execution
time rather than the kernal launch time. The Ready function can be handy here
to query the status of the timer.
``` Construct a generic timer
// Assume CUDA is enabled on the machine
vtkm::cont::Timer timer;
timer.Start();
// Run the algorithm
auto timeHost = timer.GetElapsedTime(vtkm::cont::DeviceAdapterTagSerial());
// To avoid the expensive device synchronization, we query is ready here.
if (timer.IsReady())
{
auto timeDevice = timer.GetElapsedTime(vtkm::cont::DeviceAdapterTagCuda());
}
// Force the synchronization. Ideally device execution time would be returned
which takes longer time than ther kernal call
auto timeGeneral = timer.GetElapsedTime();
```
* Create a Timer with a specific device.
* It works as the old timer that times for a specific device id.
``` Construct a device specific timer
// Assume TBB is enabled on the machine
vtkm::cont::Timer timer{vtkm::cont::DeviceAdaptertagTBB()};
timer.Start(); // t0
// Run the algorithm
// Timer would just return 0 and warn the user in the logger that an invalid
// device is used to query elapsed time
auto timeInvalid = timer.GetElapsedTime(vtkm::cont::DeviceAdapterTagSerial());
if timer.IsReady()
{
// Either will work and mark t1, return t1-t0
auto time1TBB = timer.GetElapsedTime(vtkm::cont::DeviceAdapterTagTBB());
auto time1General = timer.GetElapsedTime();
}
// Do something
auto time2 = timer.GetElapsedTime(); // t2 will be marked and t2-t0 will be returned
// Do something
timer.Stop() // t3 marked
// Do something then summarize latter
auto timeFinal = timer.GetElapsedTime(); // t3-t0
```

9
docs/changelog/verify-cmake-install.md Normal file
View File

@ -0,0 +1,9 @@
# VTK-m now can verify that it installs itself correctly
It was a fairly common occurrence of VTK-m to have a broken install
tree as it had no easy way to verify that all headers would be installed.
Now VTK-m offers a testing infrastructure that creates a temporary installed
version and is able to run tests with that VTK-m installed version. Currently
the only test is to verify that each header listed in VTK-m is also installed,
but this can expand in the future to include compilation tests.

17
docs/changelog/vtkm-handles-busy-cuda-devices-better.md Normal file
View File

@ -0,0 +1,17 @@
# VTK-m CUDA detection properly handles busy devices
When an application that uses VTK-m is first launched it will
do a check to see if CUDA is supported at runtime. If for
some reason that CUDA card is not allowing kernel execution
VTK-m would report the hardware doesn't have CUDA support.
This was problematic as was over aggressive in disabling CUDA
support for hardware that could support kernel execution in
the future. With the fact that every VTK-m worklet is executed
through a TryExecute it is no longer necessary to be so
aggressive in disabling CUDA support.
Now the behavior is that VTK-m considers a machine to have
CUDA runtime support if it has 1+ GPU's of Kepler or
higher hardware (SM_30+).

11
docs/changelog/vtkm-mangle-diy.md Normal file
View File

@ -0,0 +1,11 @@
# VTK-m thirdparty diy now can coexist with external diy
Previously VTK-m would leak macros that would cause an
external diy to be incorrectly mangled breaking consumers
of VTK-m that used diy.
Going forward to use `diy` from VTK-m all calls must use the
`vtkmdiy` namespace instead of the `diy` namespace. This
allows for VTK-m to properly forward calls to either
the external or internal version correctly.

6
examples/clipping/CMakeLists.txt
View File

@ -28,13 +28,13 @@ find_package(VTKm REQUIRED QUIET)
add_executable(Clipping_SERIAL Clipping.cxx)
target_compile_definitions(Clipping_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_link_libraries(Clipping_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Clipping_SERIAL PRIVATE vtkm_filter)
if(TARGET vtkm::tbb)
add_executable(Clipping_TBB Clipping.cxx)
target_compile_definitions(Clipping_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
target_link_libraries(Clipping_TBB PRIVATE vtkm_cont)
target_link_libraries(Clipping_TBB PRIVATE vtkm_filter)
endif()
if(TARGET vtkm::cuda)
@ -43,5 +43,5 @@ if(TARGET vtkm::cuda)
target_compile_definitions(Clipping_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
target_link_libraries(Clipping_CUDA PRIVATE vtkm_cont)
target_link_libraries(Clipping_CUDA PRIVATE vtkm_filter)
endif()

10
examples/clipping/Clipping.cxx
View File

@ -85,8 +85,10 @@ int main(int argc, char* argv[])
vtkm::Float32 clipValue = std::stof(argv[argc - 2]);
vtkm::worklet::Clip clip;
vtkm::cont::Timer<> total;
vtkm::cont::Timer<> timer;
vtkm::cont::Timer total;
total.Start();
vtkm::cont::Timer timer;
timer.Start();
bool invertClip = false;
vtkm::cont::CellSetExplicit<> outputCellSet =
clip.Run(input.GetCellSet(0),
@ -100,12 +102,12 @@ int main(int argc, char* argv[])
auto inCoords = input.GetCoordinateSystem(0).GetData();
timer.Reset();
timer.Start();
auto outCoords = clip.ProcessCellField(inCoords);
vtkm::Float64 processCoordinatesTime = timer.GetElapsedTime();
output.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", outCoords));
timer.Reset();
timer.Start();
for (vtkm::Id i = 0; i < input.GetNumberOfFields(); ++i)
{
vtkm::cont::Field inField = input.GetField(i);

12
examples/contour_tree/CMakeLists.txt
View File

@ -26,10 +26,10 @@ project(ContourTree CXX)
find_package(VTKm REQUIRED QUIET)
add_executable(ContourTreeMesh2D_SERIAL ContourTreeMesh2D.cxx)
target_link_libraries(ContourTreeMesh2D_SERIAL vtkm_cont)
target_link_libraries(ContourTreeMesh2D_SERIAL vtkm_filter)
add_executable(ContourTreeMesh3D_SERIAL ContourTreeMesh3D.cxx)
target_link_libraries(ContourTreeMesh3D_SERIAL vtkm_cont)
target_link_libraries(ContourTreeMesh3D_SERIAL vtkm_filter)
target_compile_definitions(ContourTreeMesh2D_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
@ -43,8 +43,8 @@ if(TARGET vtkm::cuda)
vtkm_compile_as_cuda(cudaSource ContourTreeMesh3D.cxx)
add_executable(ContourTreeMesh3D_CUDA ${cudaSource})
target_link_libraries(ContourTreeMesh2D_CUDA vtkm_cont)
target_link_libraries(ContourTreeMesh3D_CUDA vtkm_cont)
target_link_libraries(ContourTreeMesh2D_CUDA vtkm_filter)
target_link_libraries(ContourTreeMesh3D_CUDA vtkm_filter)
target_compile_definitions(ContourTreeMesh2D_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
@ -56,8 +56,8 @@ if(TARGET vtkm::tbb)
add_executable(ContourTreeMesh2D_TBB ContourTreeMesh2D.cxx)
add_executable(ContourTreeMesh3D_TBB ContourTreeMesh3D.cxx)
target_link_libraries(ContourTreeMesh2D_TBB vtkm_cont)
target_link_libraries(ContourTreeMesh3D_TBB vtkm_cont)
target_link_libraries(ContourTreeMesh2D_TBB vtkm_filter)
target_link_libraries(ContourTreeMesh3D_TBB vtkm_filter)
target_compile_definitions(ContourTreeMesh2D_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")

12
examples/contour_tree_augmented/CMakeLists.txt
View File

@ -77,7 +77,7 @@ find_package(VTKm REQUIRED QUIET)
####################################
# Serial 2D / 3D / MC
add_executable(ContourTree_PPP2_SERIAL ContourTreeApp.cxx)
target_link_libraries(ContourTree_PPP2_SERIAL vtkm_cont)
target_link_libraries(ContourTree_PPP2_SERIAL vtkm_filter)
target_compile_definitions(ContourTree_PPP2_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
@ -88,7 +88,7 @@ target_compile_definitions(ContourTree_PPP2_SERIAL PRIVATE
# Debug Serial 2D / 3D / MC
add_executable(ContourTree_PPP2_SERIAL_DEBUG ContourTreeApp.cxx)
target_link_libraries(ContourTree_PPP2_SERIAL_DEBUG vtkm_cont)
target_link_libraries(ContourTree_PPP2_SERIAL_DEBUG vtkm_filter)
target_compile_definitions(ContourTree_PPP2_SERIAL_DEBUG PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL" "DEBUG_PRINT")
@ -96,13 +96,13 @@ target_compile_definitions(ContourTree_PPP2_SERIAL_DEBUG PRIVATE
if(TARGET vtkm::tbb)
# TBB 2D/3D/MC
add_executable(ContourTree_PPP2_TBB ContourTreeApp.cxx)
target_link_libraries(ContourTree_PPP2_TBB vtkm_cont)
target_link_libraries(ContourTree_PPP2_TBB vtkm_filter)
target_compile_definitions(ContourTree_PPP2_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB" "ENABLE_SET_NUM_THREADS")
# TBB 2D/3D/MC DEBUG
add_executable(ContourTree_PPP2_TBB_DEBUG ContourTreeApp.cxx)
target_link_libraries(ContourTree_PPP2_TBB_DEBUG vtkm_cont)
target_link_libraries(ContourTree_PPP2_TBB_DEBUG vtkm_filter)
target_compile_definitions(ContourTree_PPP2_TBB_DEBUG PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB" "ENABLE_SET_NUM_THREADS" "DEBUG_PRINT")
@ -112,14 +112,14 @@ if(TARGET vtkm::cuda)
# CUDA 2D/3D/MC
vtkm_compile_as_cuda(cudaSource ContourTreeApp.cxx)
add_executable(ContourTree_PPP2_CUDA ${cudaSource})
target_link_libraries(ContourTree_PPP2_CUDA vtkm_cont)
target_link_libraries(ContourTree_PPP2_CUDA vtkm_filter)
target_compile_definitions(ContourTree_PPP2_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
# CUDA 2D/3D/MC
# vtkm_compile_as_cuda(cudaSource ContourTreeApp.cxx)
add_executable(ContourTree_PPP2_CUDA_DEBUG ${cudaSource})
target_link_libraries(ContourTree_PPP2_CUDA_DEBUG vtkm_cont)
target_link_libraries(ContourTree_PPP2_CUDA_DEBUG vtkm_filter)
target_compile_definitions(ContourTree_PPP2_CUDA_DEBUG PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA" "DEBUG_PRINT")
endif()

8
examples/contour_tree_augmented/ContourTreeApp.cxx
View File

@ -145,8 +145,8 @@ private:
// Compute and render an isosurface for a uniform grid example
int main(int argc, char* argv[])
{
// TODO: Change timing to use logging in vtkm/cont/Logging.h
vtkm::cont::Timer<> totalTime;
vtkm::cont::Timer totalTime;
totalTime.Start();
vtkm::Float64 prevTime = 0;
vtkm::Float64 currTime = 0;
std::cout << "ContourTreePPP2Mesh <options> <fileName>" << std::endl;
@ -330,7 +330,8 @@ int main(int argc, char* argv[])
if (computeBranchDecomposition)
{
// TODO: Change timing to use logging in vtkm/cont/Logging.h
vtkm::cont::Timer<> branchDecompTimer;
vtkm::cont::Timer branchDecompTimer;
branchDecompTimer.Start();
// compute the volume for each hyperarc and superarc
cppp2_ns::IdArrayType superarcIntrinsicWeight;
cppp2_ns::IdArrayType superarcDependentWeight;
@ -346,6 +347,7 @@ int main(int argc, char* argv[])
std::cout << std::setw(42) << std::left << "Compute Volume Weights"
<< ": " << branchDecompTimer.GetElapsedTime() << " seconds" << std::endl;
branchDecompTimer.Reset();
branchDecompTimer.Start();
// compute the branch decomposition by volume
cppp2_ns::IdArrayType whichBranch;

4
examples/cosmotools/CMakeLists.txt
View File

@ -36,5 +36,5 @@ else()
add_executable(CosmoHaloFinder CosmoHaloFinder.cxx)
endif()
target_link_libraries(CosmoCenterFinder PRIVATE vtkm_cont)
target_link_libraries(CosmoHaloFinder PRIVATE vtkm_cont)
target_link_libraries(CosmoCenterFinder PRIVATE vtkm_filter)
target_link_libraries(CosmoHaloFinder PRIVATE vtkm_filter)

2
examples/game_of_life/CMakeLists.txt
View File

@ -35,5 +35,5 @@ if(TARGET OpenGL::GL AND
add_executable(GameOfLife GameOfLife.cxx LoadShaders.h)
endif()
target_link_libraries(GameOfLife PRIVATE vtkm_cont OpenGL::GL GLEW::GLEW GLUT::GLUT)
target_link_libraries(GameOfLife PRIVATE vtkm_filter OpenGL::GL GLEW::GLEW GLUT::GLUT)
endif()

3
examples/game_of_life/GameOfLife.cxx
View File

@ -250,7 +250,7 @@ struct RenderGameOfLife
}
};
vtkm::cont::Timer<vtkm::cont::DeviceAdapterTagSerial> gTimer;
vtkm::cont::Timer gTimer{ vtkm::cont::DeviceAdapterTagSerial() };
vtkm::cont::DataSet* gData = nullptr;
GameOfLife* gFilter = nullptr;
RenderGameOfLife* gRenderer = nullptr;
@ -363,6 +363,7 @@ int main(int argc, char** argv)
gFilter = &filter;
gRenderer = &renderer;
gTimer.Start();
glutDisplayFunc([]() {
const vtkm::Float32 c = static_cast<vtkm::Float32>(gTimer.GetElapsedTime());

2
examples/hello_world/CMakeLists.txt
View File

@ -37,6 +37,6 @@ if(TARGET OpenGL::GL AND
else()
add_executable(HelloWorld HelloWorld.cxx LoadShaders.h)
endif()
target_link_libraries(HelloWorld PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(HelloWorld PRIVATE vtkm_filter ${gl_libs})
endif()

3
examples/hello_world/HelloWorld.cxx
View File

@ -59,7 +59,7 @@ struct HelloVTKMInterop
vtkm::interop::BufferState VBOState;
vtkm::interop::BufferState ColorState;
vtkm::cont::Timer<> Timer;
vtkm::cont::Timer Timer;
std::vector<vtkm::Vec<T, 3>> InputData;
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> InHandle;
@ -78,6 +78,7 @@ struct HelloVTKMInterop
, OutCoords()
, OutColors()
{
Timer.Start();
int dim = 256;
this->InputData.reserve(static_cast<std::size_t>(dim * dim));
for (int i = 0; i < dim; ++i)

6
examples/histogram/CMakeLists.txt
View File

@ -28,13 +28,13 @@ if (VTKm_ENABLE_MPI)
add_executable(Histogram_SERIAL Histogram.cxx HistogramMPI.h HistogramMPI.hxx)
target_compile_definitions(Histogram_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_link_libraries(Histogram_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Histogram_SERIAL PRIVATE vtkm_filter)
if(TARGET vtkm::tbb)
add_executable(Histogram_TBB Histogram.cxx HistogramMPI.h HistogramMPI.hxx)
target_compile_definitions(Histogram_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
target_link_libraries(Histogram_TBB PRIVATE vtkm_cont)
target_link_libraries(Histogram_TBB PRIVATE vtkm_filter)
endif()
if(TARGET vtkm::cuda)
@ -43,6 +43,6 @@ if (VTKm_ENABLE_MPI)
target_compile_definitions(Histogram_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
target_link_libraries(Histogram_CUDA PRIVATE vtkm_cont)
target_link_libraries(Histogram_CUDA PRIVATE vtkm_filter)
endif()
endif()

8
examples/histogram/Histogram.cxx
View File

@ -31,11 +31,7 @@
#include <vtkm/cont/DataSetFieldAdd.h>
#include <vtkm/cont/EnvironmentTracker.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
#include <mpi.h>
@ -69,7 +65,7 @@ int main(int argc, char* argv[])
MPI_Init(&argc, &argv);
// tell VTK-m the communicator to use.
vtkm::cont::EnvironmentTracker::SetCommunicator(diy::mpi::communicator(MPI_COMM_WORLD));
vtkm::cont::EnvironmentTracker::SetCommunicator(vtkmdiy::mpi::communicator(MPI_COMM_WORLD));
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);

6
examples/histogram/HistogramMPI.hxx
View File

@ -28,11 +28,7 @@
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/cont/FieldRangeGlobalCompute.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
namespace example
{

6
examples/isosurface/CMakeLists.txt
View File

@ -34,16 +34,16 @@ if(TARGET OpenGL::GL AND
set(gl_libs OpenGL::GL OpenGL::GLU GLEW::GLEW GLUT::GLUT)
add_executable(IsosurfaceUniformGrid_SERIAL IsosurfaceUniformGrid.cxx quaternion.h)
target_link_libraries(IsosurfaceUniformGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(IsosurfaceUniformGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
if(TARGET vtkm::cuda)
add_executable(IsosurfaceUniformGrid_CUDA IsosurfaceUniformGrid.cu quaternion.h)
target_link_libraries(IsosurfaceUniformGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(IsosurfaceUniformGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
endif()
if(TARGET vtkm::tbb)
add_executable(IsosurfaceUniformGrid_TBB IsosurfaceUniformGridTBB.cxx quaternion.h)
target_link_libraries(IsosurfaceUniformGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(IsosurfaceUniformGrid_TBB PRIVATE vtkm_filter ${gl_libs})
endif()
endif()

2
examples/lagrangian/CMakeLists.txt
View File

@ -25,5 +25,5 @@ find_package(VTKm REQUIRED QUIET)
add_executable(Lagrangian_SERIAL lagrangian.cxx ABCfield.h)
target_compile_definitions(Lagrangian_SERIAL PRIVATE "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_link_libraries(Lagrangian_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Lagrangian_SERIAL PRIVATE vtkm_filter)
target_link_libraries(Lagrangian_SERIAL ${VTKm_LIBRARIES})

2
examples/multi_backend/CMakeLists.txt
View File

@ -47,4 +47,4 @@ if(TARGET vtkm::cuda)
endif()
add_executable(MultiBackend ${device_srcs} ${srcs} ${headers})
target_link_libraries(MultiBackend PRIVATE vtkm_cont Threads::Threads)
target_link_libraries(MultiBackend PRIVATE vtkm_filter Threads::Threads)

6
examples/oscillator/CMakeLists.txt
View File

@ -28,13 +28,13 @@ find_package(VTKm REQUIRED QUIET)
add_executable(Oscillator_SERIAL Oscillator.cxx)
target_compile_definitions(Oscillator_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_link_libraries(Oscillator_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Oscillator_SERIAL PRIVATE vtkm_filter)
if (TARGET vtkm::tbb)
add_executable(Oscillator_TBB Oscillator.cxx)
target_compile_definitions(Oscillator_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
target_link_libraries(Oscillator_TBB PRIVATE vtkm_cont)
target_link_libraries(Oscillator_TBB PRIVATE vtkm_filter)
endif()
if (TARGET vtkm::cuda)
@ -42,5 +42,5 @@ if (TARGET vtkm::cuda)
add_executable(Oscillator_CUDA ${oscillatorCudaSrc})
target_compile_definitions(Oscillator_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
target_link_libraries(Oscillator_CUDA PRIVATE vtkm_cont)
target_link_libraries(Oscillator_CUDA PRIVATE vtkm_filter)
endif()

6
examples/particle_advection/CMakeLists.txt
View File

@ -26,14 +26,14 @@ project(ParticleAdvection CXX)
find_package(VTKm REQUIRED QUIET)
add_executable(Particle_Advection_SERIAL ParticleAdvection.cxx)
target_link_libraries(Particle_Advection_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Particle_Advection_SERIAL PRIVATE vtkm_filter)
if(TARGET vtkm::tbb)
add_executable(Particle_Advection_TBB ParticleAdvectionTBB.cxx)
target_link_libraries(Particle_Advection_TBB PRIVATE vtkm_cont)
target_link_libraries(Particle_Advection_TBB PRIVATE vtkm_filter)
endif()
if(TARGET vtkm::cuda)
add_executable(Particle_Advection_CUDA ParticleAdvection.cu)
target_link_libraries(Particle_Advection_CUDA PRIVATE vtkm_cont)
target_link_libraries(Particle_Advection_CUDA PRIVATE vtkm_filter)
endif()

6
examples/redistribute_points/CMakeLists.txt
View File

@ -27,13 +27,13 @@ find_package(VTKm REQUIRED QUIET)
add_executable(RedistributePoints_SERIAL RedistributePoints.cxx RedistributePoints.h)
target_compile_definitions(RedistributePoints_SERIAL PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_SERIAL")
target_link_libraries(RedistributePoints_SERIAL PRIVATE vtkm_cont)
target_link_libraries(RedistributePoints_SERIAL PRIVATE vtkm_filter)
if(TARGET vtkm::tbb)
add_executable(RedistributePoints_TBB RedistributePoints.cxx RedistributePoints.h)
target_compile_definitions(RedistributePoints_TBB PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
target_link_libraries(RedistributePoints_TBB PRIVATE vtkm_cont)
target_link_libraries(RedistributePoints_TBB PRIVATE vtkm_filter)
endif()
if(TARGET vtkm::cuda)
@ -42,5 +42,5 @@ if(TARGET vtkm::cuda)
target_compile_definitions(RedistributePoints_CUDA PRIVATE
"VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_CUDA")
target_link_libraries(RedistributePoints_CUDA PRIVATE vtkm_cont)
target_link_libraries(RedistributePoints_CUDA PRIVATE vtkm_filter)
endif()

9
examples/redistribute_points/RedistributePoints.cxx
View File

@ -23,10 +23,7 @@
#include <vtkm/io/reader/VTKDataSetReader.h>
#include <vtkm/io/writer/VTKDataSetWriter.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
#include <vtkm/thirdparty/diy/diy.h>
#include "RedistributePoints.h"
@ -36,8 +33,8 @@ using std::endl;
int main(int argc, char* argv[])
{
diy::mpi::environment env(argc, argv);
auto comm = diy::mpi::communicator(MPI_COMM_WORLD);
vtkmdiy::mpi::environment env(argc, argv);
auto comm = vtkmdiy::mpi::communicator(MPI_COMM_WORLD);
vtkm::cont::EnvironmentTracker::SetCommunicator(comm);
if (argc != 3)

85
examples/redistribute_points/RedistributePoints.h
View File

@ -22,20 +22,12 @@
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/AssignerMultiBlock.h>
#include <vtkm/cont/BoundsGlobalCompute.h>
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/filter/ExtractPoints.h>
#include <vtkm/filter/Filter.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/decomposition.hpp)
#include VTKM_DIY(diy/link.hpp)
#include VTKM_DIY(diy/master.hpp)
#include VTKM_DIY(diy/proxy.hpp)
#include VTKM_DIY(diy/reduce.hpp)
#include VTKM_DIY(diy/reduce-operations.hpp)
#include VTKM_DIY(diy/types.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
#include <vtkm/thirdparty/diy/diy.h>
namespace example
{
@ -43,9 +35,9 @@ namespace example
namespace internal
{
static diy::ContinuousBounds convert(const vtkm::Bounds& bds)
static vtkmdiy::ContinuousBounds convert(const vtkm::Bounds& bds)
{
diy::ContinuousBounds result;
vtkmdiy::ContinuousBounds result;
result.min[0] = static_cast<float>(bds.X.Min);
result.min[1] = static_cast<float>(bds.Y.Min);
result.min[2] = static_cast<float>(bds.Z.Min);
@ -59,10 +51,11 @@ static diy::ContinuousBounds convert(const vtkm::Bounds& bds)
template <typename DerivedPolicy>
class Redistributor
{
const diy::RegularDecomposer<diy::ContinuousBounds>& Decomposer;
const vtkmdiy::RegularDecomposer<vtkmdiy::ContinuousBounds>& Decomposer;
const vtkm::filter::PolicyBase<DerivedPolicy>& Policy;
vtkm::cont::DataSet Extract(const vtkm::cont::DataSet& input, const diy::ContinuousBounds& bds) const
vtkm::cont::DataSet Extract(const vtkm::cont::DataSet& input,
const vtkmdiy::ContinuousBounds& bds) const
{
// extract points
vtkm::Box box(bds.min[0], bds.max[0], bds.min[1], bds.max[1], bds.min[2], bds.max[2]);
@ -76,7 +69,11 @@ class Redistributor
class ConcatenateFields
{
public:
explicit ConcatenateFields(vtkm::Id totalSize) : TotalSize(totalSize), CurrentIdx(0) {}
explicit ConcatenateFields(vtkm::Id totalSize)
: TotalSize(totalSize)
, CurrentIdx(0)
{
}
void Append(const vtkm::cont::Field& field)
{
@ -97,10 +94,7 @@ class Redistributor
this->CurrentIdx += field.GetData().GetNumberOfValues();
}
const vtkm::cont::Field& GetResult() const
{
return this->Field;
}
const vtkm::cont::Field& GetResult() const { return this->Field; }
private:
struct Allocator
@ -135,13 +129,14 @@ class Redistributor
};
public:
Redistributor(const diy::RegularDecomposer<diy::ContinuousBounds>& decomposer,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
: Decomposer(decomposer), Policy(policy)
Redistributor(const vtkmdiy::RegularDecomposer<vtkmdiy::ContinuousBounds>& decomposer,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
: Decomposer(decomposer)
, Policy(policy)
{
}
void operator()(vtkm::cont::DataSet* block, const diy::ReduceProxy& rp) const
void operator()(vtkm::cont::DataSet* block, const vtkmdiy::ReduceProxy& rp) const
{
if (rp.in_link().size() == 0)
{
@ -151,7 +146,7 @@ public:
{
auto target = rp.out_link().target(cc);
// let's get the bounding box for the target block.
diy::ContinuousBounds bds;
vtkmdiy::ContinuousBounds bds;
this->Decomposer.fill_bounds(bds, target.gid);
auto extractedDS = this->Extract(*block, bds);
@ -185,7 +180,7 @@ public:
else if (receives.size() > 1)
{
ConcatenateFields concatCoords(numValues);
for (const auto& ds: receives)
for (const auto& ds : receives)
{
concatCoords.Append(ds.GetCoordinateSystem(0));
}
@ -195,7 +190,7 @@ public:
for (vtkm::IdComponent i = 0; i < receives[0].GetNumberOfFields(); ++i)
{
ConcatenateFields concatField(numValues);
for (const auto& ds: receives)
for (const auto& ds : receives)
{
concatField.Append(ds.GetField(i));
}
@ -220,13 +215,12 @@ public:
template <typename DerivedPolicy>
VTKM_CONT vtkm::cont::MultiBlock PrepareForExecution(
const vtkm::cont::MultiBlock& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
const vtkm::cont::MultiBlock& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
};
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::MultiBlock
RedistributePoints::PrepareForExecution(
inline VTKM_CONT vtkm::cont::MultiBlock RedistributePoints::PrepareForExecution(
const vtkm::cont::MultiBlock& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
@ -236,31 +230,30 @@ RedistributePoints::PrepareForExecution(
vtkm::Bounds gbounds = vtkm::cont::BoundsGlobalCompute(input);
vtkm::cont::AssignerMultiBlock assigner(input.GetNumberOfBlocks());
diy::RegularDecomposer<diy::ContinuousBounds> decomposer(/*dim*/3, internal::convert(gbounds), assigner.nblocks());
vtkmdiy::RegularDecomposer<vtkmdiy::ContinuousBounds> decomposer(
/*dim*/ 3, internal::convert(gbounds), assigner.nblocks());
diy::Master master(comm,
/*threads*/ 1,
/*limit*/ -1,
[]() -> void* { return new vtkm::cont::DataSet(); },
[](void*ptr) { delete static_cast<vtkm::cont::DataSet*>(ptr); });
vtkmdiy::Master master(comm,
/*threads*/ 1,
/*limit*/ -1,
[]() -> void* { return new vtkm::cont::DataSet(); },
[](void* ptr) { delete static_cast<vtkm::cont::DataSet*>(ptr); });
decomposer.decompose(comm.rank(), assigner, master);
assert(static_cast<vtkm::Id>(master.size()) == input.GetNumberOfBlocks());
// let's populate local blocks
master.foreach(
[&input](vtkm::cont::DataSet* ds, const diy::Master::ProxyWithLink& proxy) {
auto lid = proxy.master()->lid(proxy.gid());
*ds = input.GetBlock(lid);
});
master.foreach ([&input](vtkm::cont::DataSet* ds, const vtkmdiy::Master::ProxyWithLink& proxy) {
auto lid = proxy.master()->lid(proxy.gid());
*ds = input.GetBlock(lid);
});
internal::Redistributor<DerivedPolicy> redistributor(decomposer, policy);
diy::all_to_all(master, assigner, redistributor, /*k=*/2);
vtkmdiy::all_to_all(master, assigner, redistributor, /*k=*/2);
vtkm::cont::MultiBlock result;
master.foreach(
[&result](vtkm::cont::DataSet* ds, const diy::Master::ProxyWithLink&) {
result.AddBlock(*ds);
});
master.foreach ([&result](vtkm::cont::DataSet* ds, const vtkmdiy::Master::ProxyWithLink&) {
result.AddBlock(*ds);
});
return result;
}

6
examples/streamline/CMakeLists.txt
View File

@ -33,16 +33,16 @@ if(TARGET OpenGL::GL AND
set(gl_libs OpenGL::GL OpenGL::GLU GLEW::GLEW GLUT::GLUT)
add_executable(StreamLineUniformGrid_SERIAL StreamLineUniformGrid.cxx)
target_link_libraries(StreamLineUniformGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(StreamLineUniformGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
if(TARGET vtkm::cont)
add_executable(StreamLineUniformGrid_CUDA StreamLineUniformGrid.cu)
target_link_libraries(StreamLineUniformGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(StreamLineUniformGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
endif()
if(TARGET vtkm::tbb)
add_executable(StreamLineUniformGrid_TBB StreamLineUniformGridTBB.cxx)
target_link_libraries(StreamLineUniformGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(StreamLineUniformGrid_TBB PRIVATE vtkm_filter ${gl_libs})
endif()
endif()

6
examples/temporal_advection/CMakeLists.txt
View File

@ -28,14 +28,14 @@ project(TemporalAdvection CXX)
find_package(VTKm REQUIRED QUIET)
add_executable(Temporal_Advection_SERIAL TemporalAdvection.cxx)
target_link_libraries(Temporal_Advection_SERIAL PRIVATE vtkm_cont)
target_link_libraries(Temporal_Advection_SERIAL PRIVATE vtkm_filter)
if(TARGET vtkm::tbb)
add_executable(Temporal_Advection_TBB TemporalAdvectionTBB.cxx)
target_link_libraries(Temporal_Advection_TBB PRIVATE vtkm_cont)
target_link_libraries(Temporal_Advection_TBB PRIVATE vtkm_filter)
endif()
if(TARGET vtkm::cuda)
add_executable(Temporal_Advection_CUDA TemporalAdvection.cu)
target_link_libraries(Temporal_Advection_CUDA PRIVATE vtkm_cont)
target_link_libraries(Temporal_Advection_CUDA PRIVATE vtkm_filter)
endif()

24
examples/tetrahedra/CMakeLists.txt
View File

@ -37,10 +37,10 @@ if(TARGET OpenGL::GL AND
add_executable(TetrahedralizeUniformGrid_SERIAL TetrahedralizeUniformGrid.cxx)
add_executable(TriangulateUniformGrid_SERIAL TriangulateUniformGrid.cxx)
target_link_libraries(TetrahedralizeExplicitGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateUniformGrid_SERIAL PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeExplicitGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateUniformGrid_SERIAL PRIVATE vtkm_filter ${gl_libs})
if(TARGET vtkm::cuda)
add_executable(TetrahedralizeExplicitGrid_CUDA TetrahedralizeExplicitGrid.cu)
@ -48,10 +48,10 @@ if(TARGET OpenGL::GL AND
add_executable(TetrahedralizeUniformGrid_CUDA TetrahedralizeUniformGrid.cu)
add_executable(TriangulateUniformGrid_CUDA TriangulateUniformGrid.cu)
target_link_libraries(TetrahedralizeExplicitGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateUniformGrid_CUDA PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeExplicitGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateUniformGrid_CUDA PRIVATE vtkm_filter ${gl_libs})
endif()
if(TARGET vtkm::tbb)
@ -60,9 +60,9 @@ if(TARGET OpenGL::GL AND
add_executable(TetrahedralizeUniformGrid_TBB TetrahedralizeUniformGridTBB.cxx)
add_executable(TriangulateUniformGrid_TBB TriangulateUniformGridTBB.cxx)
target_link_libraries(TetrahedralizeExplicitGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TriangulateUniformGrid_TBB PRIVATE vtkm_cont ${gl_libs})
target_link_libraries(TetrahedralizeExplicitGrid_TBB PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateExplicitGrid_TBB PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TetrahedralizeUniformGrid_TBB PRIVATE vtkm_filter ${gl_libs})
target_link_libraries(TriangulateUniformGrid_TBB PRIVATE vtkm_filter ${gl_libs})
endif()
endif()

2
examples/unified_memory/CMakeLists.txt
View File

@ -27,6 +27,6 @@ find_package(VTKm REQUIRED QUIET)
if(TARGET vtkm::cuda)
add_executable(UnifiedMemory_CUDA UnifiedMemory.cu)
target_link_libraries(UnifiedMemory_CUDA PRIVATE vtkm_cont)
target_link_libraries(UnifiedMemory_CUDA PRIVATE vtkm_filter)
endif()

6
examples/unified_memory/UnifiedMemory.cu
View File

@ -84,7 +84,8 @@ int main(int argc, char* argv[])
//run once to get the CUDA code warmed up
dispatcher.Invoke(input, output);
vtkm::cont::Timer<DeviceTag> timer;
vtkm::cont::Timer timer{ DeviceTag() };
timer.Start();
for (int i = 0; i < 3; ++i)
{
@ -117,7 +118,8 @@ int main(int argc, char* argv[])
//run once to get the CUDA code warmed up
dispatcher.Invoke(input, output);
vtkm::cont::Timer<DeviceTag> timer;
vtkm::cont::Timer timer{ DeviceTag() };
timer.Start();
for (int i = 0; i < 3; ++i)
{

1
vtkm/CMakeLists.txt
View File

@ -47,6 +47,7 @@ set(headers
Pair.h
Range.h
RangeId.h
RangeId2.h
RangeId3.h
StaticAssert.h
Swap.h

2
vtkm/Math.h
View File

@ -36,7 +36,7 @@
#include <stdlib.h>
#endif // !VTKM_CUDA
#if !defined(__CUDA_ARCH__)
#if !defined(VTKM_CUDA_DEVICE_PASS)
#define VTKM_USE_STL
#include <algorithm>
#endif

2
vtkm/Math.h.in
View File

@ -48,7 +48,7 @@ $# Ignore the following comment. It is meant for the generated file.
#include <stdlib.h>
#endif // !VTKM_CUDA
#if !defined(__CUDA_ARCH__)
#if !defined(VTKM_CUDA_DEVICE_PASS)
#define VTKM_USE_STL
#include <algorithm>
#endif

166
vtkm/RangeId2.h Normal file
View File

@ -0,0 +1,166 @@
//============================================================================
// 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 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2017 UT-Battelle, LLC.
// Copyright 2017 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// 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_RangeId2_h
#define vtk_m_RangeId2_h
#include <vtkm/RangeId.h>
namespace vtkm
{
/// \brief Represent 2D integer range.
///
/// \c vtkm::RangeId2 is a helper class for representing a 2D range of integer
/// values. The typical use of this class is to express a box of indices
/// in the x, y, and z directions.
///
/// \c RangeId2 also contains several helper functions for computing and
/// maintaining the range.
///
struct RangeId2
{
vtkm::RangeId X;
vtkm::RangeId Y;
RangeId2() = default;
VTKM_EXEC_CONT
RangeId2(const vtkm::RangeId& xrange, const vtkm::RangeId& yrange)
: X(xrange)
, Y(yrange)
{
}
VTKM_EXEC_CONT
RangeId2(vtkm::Id minX, vtkm::Id maxX, vtkm::Id minY, vtkm::Id maxY)
: X(vtkm::RangeId(minX, maxX))
, Y(vtkm::RangeId(minY, maxY))
{
}
/// Initialize range with an array of 6 values in the order xmin, xmax,
/// ymin, ymax, zmin, zmax.
///
VTKM_EXEC_CONT
explicit RangeId2(const vtkm::Id range[4])
: X(vtkm::RangeId(range[0], range[1]))
, Y(vtkm::RangeId(range[2], range[3]))
{
}
/// Initialize range with the minimum and the maximum corners
///
VTKM_EXEC_CONT
RangeId2(const vtkm::Id2& min, const vtkm::Id2& max)
: X(vtkm::RangeId(min[0], max[0]))
, Y(vtkm::RangeId(min[1], max[1]))
{
}
/// \b Determine if the range is non-empty.
///
/// \c IsNonEmpty returns true if the range is non-empty.
///
VTKM_EXEC_CONT
bool IsNonEmpty() const { return (this->X.IsNonEmpty() && this->Y.IsNonEmpty()); }
/// \b Determines if an Id2 value is within the range.
///
VTKM_EXEC_CONT
bool Contains(const vtkm::Id2& val) const
{
return (this->X.Contains(val[0]) && this->Y.Contains(val[1]));
}
/// \b Returns the center of the range.
///
/// \c Center computes the middle of the range.
///
VTKM_EXEC_CONT
vtkm::Id2 Center() const { return vtkm::Id2(this->X.Center(), this->Y.Center()); }
VTKM_EXEC_CONT
vtkm::Id2 Dimensions() const { return vtkm::Id2(this->X.Length(), this->Y.Length()); }
/// \b Expand range to include a value.
///
/// This version of \c Include expands the range just enough to include the
/// given value. If the range already include this value, then
/// nothing is done.
///
template <typename T>
VTKM_EXEC_CONT void Include(const vtkm::Vec<T, 2>& point)
{
this->X.Include(point[0]);
this->Y.Include(point[1]);
}
/// \b Expand range to include other range.
///
/// This version of \c Include expands the range just enough to include
/// the other range. Essentially it is the union of the two ranges.
///
VTKM_EXEC_CONT
void Include(const vtkm::RangeId2& range)
{
this->X.Include(range.X);
this->Y.Include(range.Y);
}
/// \b Return the union of this and another range.
///
/// This is a nondestructive form of \c Include.
///
VTKM_EXEC_CONT
vtkm::RangeId2 Union(const vtkm::RangeId2& other) const
{
vtkm::RangeId2 unionRangeId2(*this);
unionRangeId2.Include(other);
return unionRangeId2;
}
/// \b Operator for union
///
VTKM_EXEC_CONT
vtkm::RangeId2 operator+(const vtkm::RangeId2& other) const { return this->Union(other); }
VTKM_EXEC_CONT
bool operator==(const vtkm::RangeId2& range) const
{
return ((this->X == range.X) && (this->Y == range.Y));
}
VTKM_EXEC_CONT
bool operator!=(const vtkm::RangeId2& range) const
{
return ((this->X != range.X) || (this->Y != range.Y));
}
};
} // namespace vtkm
/// Helper function for printing range during testing
///
static inline VTKM_CONT std::ostream& operator<<(std::ostream& stream, const vtkm::RangeId2& range)
{
return stream << "{ X:" << range.X << ", Y:" << range.Y << " }";
}
#endif //vtk_m_RangeId2_h

4
vtkm/cont/ArrayHandle.h
View File

@ -696,14 +696,14 @@ namespace internal
{
template <typename T, typename S>
void VTKM_CONT ArrayHandleDefaultSerialization(diy::BinaryBuffer& bb,
void VTKM_CONT ArrayHandleDefaultSerialization(vtkmdiy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandle<T, S>& obj);
} // internal
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename T>

28
vtkm/cont/ArrayHandle.hxx
View File

@ -357,36 +357,36 @@ namespace internal
namespace detail
{
template <typename ArrayHandle>
inline void VTKM_CONT StorageSerialization(diy::BinaryBuffer& bb,
inline void VTKM_CONT StorageSerialization(vtkmdiy::BinaryBuffer& bb,
const ArrayHandle& obj,
std::false_type)
{
vtkm::Id count = obj.GetNumberOfValues();
diy::save(bb, count);
vtkmdiy::save(bb, count);
diy::save(bb, vtkm::Id(0)); //not a basic storage
vtkmdiy::save(bb, vtkm::Id(0)); //not a basic storage
auto portal = obj.GetPortalConstControl();
for (vtkm::Id i = 0; i < count; ++i)
{
diy::save(bb, portal.Get(i));
vtkmdiy::save(bb, portal.Get(i));
}
}
template <typename ArrayHandle>
inline void VTKM_CONT StorageSerialization(diy::BinaryBuffer& bb,
inline void VTKM_CONT StorageSerialization(vtkmdiy::BinaryBuffer& bb,
const ArrayHandle& obj,
std::true_type)
{
vtkm::Id count = obj.GetNumberOfValues();
diy::save(bb, count);
vtkmdiy::save(bb, count);
diy::save(bb, vtkm::Id(1)); //is basic storage
diy::save(bb, obj.GetStorage().GetArray(), static_cast<std::size_t>(count));
vtkmdiy::save(bb, vtkm::Id(1)); //is basic storage
vtkmdiy::save(bb, obj.GetStorage().GetArray(), static_cast<std::size_t>(count));
}
}
template <typename T, typename S>
inline void VTKM_CONT ArrayHandleDefaultSerialization(diy::BinaryBuffer& bb,
inline void VTKM_CONT ArrayHandleDefaultSerialization(vtkmdiy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandle<T, S>& obj)
{
using is_basic = typename std::is_same<S, vtkm::cont::StorageTagBasic>::type;
@ -396,7 +396,7 @@ inline void VTKM_CONT ArrayHandleDefaultSerialization(diy::BinaryBuffer& bb,
}
} // vtkm::cont::internal
namespace diy
namespace mangled_diy_namespace
{
template <typename T>
@ -404,14 +404,14 @@ VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T>>::load(BinaryBuffer& bb,
vtkm::cont::ArrayHandle<T>& obj)
{
vtkm::Id count = 0;
diy::load(bb, count);
vtkmdiy::load(bb, count);
obj.Allocate(count);
vtkm::Id input_was_basic_storage = 0;
diy::load(bb, input_was_basic_storage);
vtkmdiy::load(bb, input_was_basic_storage);
if (input_was_basic_storage)
{
diy::load(bb, obj.GetStorage().GetArray(), static_cast<std::size_t>(count));
vtkmdiy::load(bb, obj.GetStorage().GetArray(), static_cast<std::size_t>(count));
}
else
{
@ -419,7 +419,7 @@ VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T>>::load(BinaryBuffer& bb,
for (vtkm::Id i = 0; i < count; ++i)
{
T val{};
diy::load(bb, val);
vtkmdiy::load(bb, val);
portal.Set(i, val);
}
}

14
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -458,7 +458,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH1, typename AH2, typename AH3>
@ -472,9 +472,9 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetFirstArray());
diy::save(bb, storage.GetSecondArray());
diy::save(bb, storage.GetThirdArray());
vtkmdiy::save(bb, storage.GetFirstArray());
vtkmdiy::save(bb, storage.GetSecondArray());
vtkmdiy::save(bb, storage.GetThirdArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -483,9 +483,9 @@ public:
AH2 array2;
AH3 array3;
diy::load(bb, array1);
diy::load(bb, array2);
diy::load(bb, array3);
vtkmdiy::load(bb, array1);
vtkmdiy::load(bb, array2);
vtkmdiy::load(bb, array3);
obj = vtkm::cont::make_ArrayHandleCartesianProduct(array1, array2, array3);
}

2
vtkm/cont/ArrayHandleCast.h
View File

@ -129,7 +129,7 @@ struct TypeString<vtkm::cont::ArrayHandleCast<T, AH>>
}
} // namespace vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename T1, typename T2>

6
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -752,7 +752,7 @@ struct TypeString<vtkm::cont::ArrayHandle<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
namespace internal
@ -804,7 +804,7 @@ private:
template <typename AH>
void operator()(const AH& ah, BinaryBuffer& bb) const
{
diy::save(bb, ah);
vtkmdiy::save(bb, ah);
}
};
@ -813,7 +813,7 @@ private:
template <typename AH>
void operator()(AH& ah, BinaryBuffer& bb) const
{
diy::load(bb, ah);
vtkmdiy::load(bb, ah);
}
};

10
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -351,7 +351,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH1, typename AH2>
@ -365,8 +365,8 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray1());
diy::save(bb, storage.GetArray2());
vtkmdiy::save(bb, storage.GetArray1());
vtkmdiy::save(bb, storage.GetArray2());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -374,8 +374,8 @@ public:
AH1 array1;
AH2 array2;
diy::load(bb, array1);
diy::load(bb, array2);
vtkmdiy::load(bb, array1);
vtkmdiy::load(bb, array2);
obj = vtkm::cont::make_ArrayHandleConcatenate(array1, array2);
}

2
vtkm/cont/ArrayHandleConstant.h
View File

@ -110,7 +110,7 @@ struct TypeString<vtkm::cont::ArrayHandleConstant<T>>
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename T>

14
vtkm/cont/ArrayHandleCounting.h
View File

@ -174,7 +174,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename T>
@ -188,9 +188,9 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
diy::save(bb, portal.GetStart());
diy::save(bb, portal.GetStep());
diy::save(bb, portal.GetNumberOfValues());
vtkmdiy::save(bb, portal.GetStart());
vtkmdiy::save(bb, portal.GetStep());
vtkmdiy::save(bb, portal.GetNumberOfValues());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -198,9 +198,9 @@ public:
T start{}, step{};
vtkm::Id count = 0;
diy::load(bb, start);
diy::load(bb, step);
diy::load(bb, count);
vtkmdiy::load(bb, start);
vtkmdiy::load(bb, step);
vtkmdiy::load(bb, count);
obj = vtkm::cont::make_ArrayHandleCounting(start, step, count);
}

10
vtkm/cont/ArrayHandleExtractComponent.h
View File

@ -337,7 +337,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH>
@ -351,16 +351,16 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetComponent());
diy::save(bb, storage.GetArray());
vtkmdiy::save(bb, storage.GetComponent());
vtkmdiy::save(bb, storage.GetArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkm::IdComponent component = 0;
AH array;
diy::load(bb, component);
diy::load(bb, array);
vtkmdiy::load(bb, component);
vtkmdiy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleExtractComponent(array, component);
}

6
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -393,7 +393,7 @@ struct TypeString<vtkm::cont::ArrayHandle<vtkm::Vec<typename AH::ValueType, NUM_
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH, vtkm::IdComponent NUM_COMPS>
@ -406,13 +406,13 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetSourceArray());
vtkmdiy::save(bb, obj.GetStorage().GetSourceArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleGroupVec<NUM_COMPS>(array);
}

10
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -534,7 +534,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename SAH, typename OAH>
@ -547,8 +547,8 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetSourceArray());
diy::save(bb, obj.GetStorage().GetOffsetsArray());
vtkmdiy::save(bb, obj.GetStorage().GetSourceArray());
vtkmdiy::save(bb, obj.GetStorage().GetOffsetsArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -556,8 +556,8 @@ public:
SAH src;
OAH off;
diy::load(bb, src);
diy::load(bb, off);
vtkmdiy::load(bb, src);
vtkmdiy::load(bb, off);
obj = vtkm::cont::make_ArrayHandleGroupVecVariable(src, off);
}

10
vtkm/cont/ArrayHandleImplicit.h
View File

@ -173,7 +173,7 @@ struct TypeString<vtkm::cont::ArrayHandle<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename Functor>
@ -186,17 +186,17 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetNumberOfValues());
diy::save(bb, obj.GetPortalConstControl().GetFunctor());
vtkmdiy::save(bb, obj.GetNumberOfValues());
vtkmdiy::save(bb, obj.GetPortalConstControl().GetFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkm::Id count = 0;
diy::load(bb, count);
vtkmdiy::load(bb, count);
Functor functor;
diy::load(bb, functor);
vtkmdiy::load(bb, functor);
obj = vtkm::cont::make_ArrayHandleImplicit(functor, count);
}

2
vtkm/cont/ArrayHandleIndex.h
View File

@ -83,7 +83,7 @@ struct TypeString<vtkm::cont::ArrayHandleIndex>
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <>

10
vtkm/cont/ArrayHandlePermutation.h
View File

@ -400,7 +400,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename IdxAH, typename ValAH>
@ -414,8 +414,8 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetIndexArray());
diy::save(bb, storage.GetValueArray());
vtkmdiy::save(bb, storage.GetIndexArray());
vtkmdiy::save(bb, storage.GetValueArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -423,8 +423,8 @@ public:
IdxAH indices;
ValAH values;
diy::load(bb, indices);
diy::load(bb, values);
vtkmdiy::load(bb, indices);
vtkmdiy::load(bb, values);
obj = vtkm::cont::make_ArrayHandlePermutation(indices, values);
}

6
vtkm/cont/ArrayHandleReverse.h
View File

@ -269,7 +269,7 @@ struct TypeString<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH>
@ -282,13 +282,13 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetArray());
vtkmdiy::save(bb, obj.GetStorage().GetArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleReverse(array);
}
};

10
vtkm/cont/ArrayHandleSwizzle.h
View File

@ -426,7 +426,7 @@ struct TypeString<vtkm::cont::ArrayHandle<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH, vtkm::IdComponent NComps>
@ -440,16 +440,16 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetMap());
vtkmdiy::save(bb, storage.GetArray());
vtkmdiy::save(bb, storage.GetMap());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
vtkm::Vec<vtkm::IdComponent, NComps> map;
diy::load(bb, map);
vtkmdiy::load(bb, map);
obj = vtkm::cont::make_ArrayHandleSwizzle(array, map);
}
};

22
vtkm/cont/ArrayHandleTransform.h
View File

@ -778,7 +778,7 @@ struct TypeString<vtkm::cont::ArrayHandle<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH, typename Functor>
@ -792,16 +792,16 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetFunctor());
vtkmdiy::save(bb, storage.GetArray());
vtkmdiy::save(bb, storage.GetFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
Functor functor;
diy::load(bb, functor);
vtkmdiy::load(bb, functor);
obj = vtkm::cont::make_ArrayHandleTransform(array, functor);
}
};
@ -817,19 +817,19 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetFunctor());
diy::save(bb, storage.GetInverseFunctor());
vtkmdiy::save(bb, storage.GetArray());
vtkmdiy::save(bb, storage.GetFunctor());
vtkmdiy::save(bb, storage.GetInverseFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
Functor functor;
diy::load(bb, functor);
vtkmdiy::load(bb, functor);
InvFunctor invFunctor;
diy::load(bb, invFunctor);
vtkmdiy::load(bb, invFunctor);
obj = vtkm::cont::make_ArrayHandleTransform(array, functor, invFunctor);
}
};

14
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -85,7 +85,7 @@ struct TypeString<vtkm::cont::ArrayHandle<
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <>
@ -99,9 +99,9 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
diy::save(bb, portal.GetDimensions());
diy::save(bb, portal.GetOrigin());
diy::save(bb, portal.GetSpacing());
vtkmdiy::save(bb, portal.GetDimensions());
vtkmdiy::save(bb, portal.GetOrigin());
vtkmdiy::save(bb, portal.GetSpacing());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -109,9 +109,9 @@ public:
vtkm::Id3 dims;
typename BaseType::ValueType origin, spacing;
diy::load(bb, dims);
diy::load(bb, origin);
diy::load(bb, spacing);
vtkmdiy::load(bb, dims);
vtkmdiy::load(bb, origin);
vtkmdiy::load(bb, spacing);
obj = vtkm::cont::ArrayHandleUniformPointCoordinates(dims, origin, spacing);
}

28
vtkm/cont/ArrayHandleVirtual.hxx
View File

@ -53,14 +53,15 @@ ArrayHandleType inline ArrayHandle<T, StorageTagVirtual>::CastToType(
//=============================================================================
// Specializations of serialization related classes
namespace diy
namespace mangled_diy_namespace
{
template <typename T>
struct Serialization<vtkm::cont::ArrayHandleVirtual<T>>
{
static VTKM_CONT void save(diy::BinaryBuffer& bb, const vtkm::cont::ArrayHandleVirtual<T>& obj)
static VTKM_CONT void save(vtkmdiy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandleVirtual<T>& obj)
{
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
@ -68,7 +69,7 @@ struct Serialization<vtkm::cont::ArrayHandleVirtual<T>>
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::ArrayHandleVirtual<T>& obj)
{
vtkm::cont::ArrayHandle<T> array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = std::move(vtkm::cont::ArrayHandleVirtual<T>{ array });
}
};
@ -80,29 +81,30 @@ struct IntAnySerializer
using ConstantType = vtkm::cont::ArrayHandleConstant<T>;
using BasicType = vtkm::cont::ArrayHandle<T>;
static VTKM_CONT void save(diy::BinaryBuffer& bb, const vtkm::cont::ArrayHandleVirtual<T>& obj)
static VTKM_CONT void save(vtkmdiy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandleVirtual<T>& obj)
{
if (obj.template IsType<CountingType>())
{
diy::save(bb, vtkm::cont::TypeString<CountingType>::Get());
vtkmdiy::save(bb, vtkm::cont::TypeString<CountingType>::Get());
using S = typename CountingType::StorageTag;
const vtkm::cont::StorageVirtual* storage = obj.GetStorage();
auto* any = storage->Cast<vtkm::cont::StorageAny<T, S>>();
diy::save(bb, any->GetHandle());
vtkmdiy::save(bb, any->GetHandle());
}
else if (obj.template IsType<ConstantType>())
{
diy::save(bb, vtkm::cont::TypeString<ConstantType>::Get());
vtkmdiy::save(bb, vtkm::cont::TypeString<ConstantType>::Get());
using S = typename ConstantType::StorageTag;
const vtkm::cont::StorageVirtual* storage = obj.GetStorage();
auto* any = storage->Cast<vtkm::cont::StorageAny<T, S>>();
diy::save(bb, any->GetHandle());
vtkmdiy::save(bb, any->GetHandle());
}
else
{
diy::save(bb, vtkm::cont::TypeString<BasicType>::Get());
vtkmdiy::save(bb, vtkm::cont::TypeString<BasicType>::Get());
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
}
@ -110,24 +112,24 @@ struct IntAnySerializer
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::ArrayHandleVirtual<T>& obj)
{
std::string typeString;
diy::load(bb, typeString);
vtkmdiy::load(bb, typeString);
if (typeString == vtkm::cont::TypeString<CountingType>::Get())
{
CountingType array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = std::move(vtkm::cont::ArrayHandleVirtual<T>{ array });
}
else if (typeString == vtkm::cont::TypeString<ConstantType>::Get())
{
ConstantType array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = std::move(vtkm::cont::ArrayHandleVirtual<T>{ array });
}
else
{
vtkm::cont::ArrayHandle<T> array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = std::move(vtkm::cont::ArrayHandleVirtual<T>{ array });
}
}

20
vtkm/cont/ArrayHandleVirtualCoordinates.h
View File

@ -106,7 +106,7 @@ struct TypeString<vtkm::cont::ArrayHandleVirtualCoordinates>
//=============================================================================
// Specializations of serialization related classes
namespace diy
namespace mangled_diy_namespace
{
template <>
@ -132,8 +132,8 @@ public:
using T = typename HandleType::ValueType;
using S = typename HandleType::StorageTag;
auto array = storage->Cast<vtkm::cont::StorageAny<T, S>>();
diy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
diy::save(bb, array->GetHandle());
vtkmdiy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
vtkmdiy::save(bb, array->GetHandle());
}
else if (obj.IsType<RectilinearCoordsArrayType>())
{
@ -141,12 +141,12 @@ public:
using T = typename HandleType::ValueType;
using S = typename HandleType::StorageTag;
auto array = storage->Cast<vtkm::cont::StorageAny<T, S>>();
diy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
diy::save(bb, array->GetHandle());
vtkmdiy::save(bb, vtkm::cont::TypeString<HandleType>::Get());
vtkmdiy::save(bb, array->GetHandle());
}
else
{
diy::save(bb, vtkm::cont::TypeString<BasicCoordsType>::Get());
vtkmdiy::save(bb, vtkm::cont::TypeString<BasicCoordsType>::Get());
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
}
@ -154,24 +154,24 @@ public:
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
std::string typeString;
diy::load(bb, typeString);
vtkmdiy::load(bb, typeString);
if (typeString == vtkm::cont::TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>::Get())
{
vtkm::cont::ArrayHandleUniformPointCoordinates array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<RectilinearCoordsArrayType>::Get())
{
RectilinearCoordsArrayType array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<BasicCoordsType>::Get())
{
BasicCoordsType array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else

10
vtkm/cont/ArrayHandleZip.h
View File

@ -412,7 +412,7 @@ struct TypeString<
}
} // namespace vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename AH1, typename AH2>
@ -426,8 +426,8 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetFirstArray());
diy::save(bb, storage.GetSecondArray());
vtkmdiy::save(bb, storage.GetFirstArray());
vtkmdiy::save(bb, storage.GetSecondArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
@ -435,8 +435,8 @@ public:
AH1 a1;
AH2 a2;
diy::load(bb, a1);
diy::load(bb, a2);
vtkmdiy::load(bb, a1);
vtkmdiy::load(bb, a2);
obj = vtkm::cont::make_ArrayHandleZip(a1, a2);
}

13
vtkm/cont/AssignerMultiBlock.cxx
View File

@ -22,11 +22,8 @@
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/MultiBlock.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
#include <algorithm> // std::lower_bound
#include <numeric> // std::iota
@ -44,15 +41,15 @@ AssignerMultiBlock::AssignerMultiBlock(const vtkm::cont::MultiBlock& mb)
VTKM_CONT
AssignerMultiBlock::AssignerMultiBlock(vtkm::Id num_blocks)
: diy::StaticAssigner(vtkm::cont::EnvironmentTracker::GetCommunicator().size(), 1)
: vtkmdiy::StaticAssigner(vtkm::cont::EnvironmentTracker::GetCommunicator().size(), 1)
, IScanBlockCounts()
{
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
if (comm.size() > 1)
{
vtkm::Id iscan;
diy::mpi::scan(comm, num_blocks, iscan, std::plus<vtkm::Id>());
diy::mpi::all_gather(comm, iscan, this->IScanBlockCounts);
vtkmdiy::mpi::scan(comm, num_blocks, iscan, std::plus<vtkm::Id>());
vtkmdiy::mpi::all_gather(comm, iscan, this->IScanBlockCounts);
}
else
{

12
vtkm/cont/AssignerMultiBlock.h
View File

@ -28,11 +28,7 @@
#include <vector>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/assigner.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
#ifdef VTKM_MSVC
#pragma warning(push)
@ -49,7 +45,7 @@ class MultiBlock;
/// \brief Assigner for `MultiBlock` blocks.
///
/// `AssignerMultiBlock` is a `diy::StaticAssigner` implementation that uses
/// `AssignerMultiBlock` is a `vtkmdiy::StaticAssigner` implementation that uses
/// `MultiBlock`'s block distribution to build global-id/rank associations
/// needed for several `diy` operations.
/// It uses a contiguous assignment strategy to map blocks to global ids i.e.
@ -59,7 +55,7 @@ class MultiBlock;
/// essential it gets created on all ranks irrespective of whether the rank has
/// any blocks.
///
class VTKM_CONT_EXPORT AssignerMultiBlock : public diy::StaticAssigner
class VTKM_CONT_EXPORT AssignerMultiBlock : public vtkmdiy::StaticAssigner
{
public:
/// Initialize the assigner using a multiblock dataset.
@ -72,7 +68,7 @@ public:
AssignerMultiBlock(vtkm::Id num_blocks);
///@{
/// diy::Assigner API implementation.
/// vtkmdiy::Assigner API implementation.
VTKM_CONT
void local_gids(int rank, std::vector<int>& gids) const override;

6
vtkm/cont/CMakeLists.txt
View File

@ -125,6 +125,7 @@ set(template_sources
StorageAny.hxx
StorageBasic.hxx
StorageVirtual.hxx
VirtualObjectHandle.hxx
)
set(sources
@ -170,6 +171,7 @@ set(device_sources
ArrayRangeCompute.cxx
CellSetExplicit.cxx
CoordinateSystem.cxx
Timer.cxx
)
#-----------------------------------------------------------------------------
@ -199,7 +201,9 @@ if(TARGET vtkm::openmp)
list(APPEND backends vtkm::openmp)
endif()
if (VTKm_ENABLE_LOGGING)
list(APPEND DL_LIBS ${CMAKE_DL_LIBS}) # dladdr function
set(THREADS_PREFER_PTHREAD_FLAG ON)
find_package(Threads REQUIRED)
list(APPEND DL_LIBS ${CMAKE_DL_LIBS} Threads::Threads) # dladdr function
endif()
target_link_libraries(vtkm_cont PUBLIC vtkm_compiler_flags ${backends} ${DL_LIBS})
if(TARGET vtkm_diy)

28
vtkm/cont/CellSetExplicit.h
View File

@ -366,7 +366,7 @@ struct TypeString<vtkm::cont::CellSetExplicit<ShapeST, CountST, ConnectivityST,
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename ShapeST, typename CountST, typename ConnectivityST, typename OffsetST>
@ -378,32 +378,32 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetNumberOfPoints());
diy::save(bb,
cs.GetShapesArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
vtkmdiy::save(bb, cs.GetName());
vtkmdiy::save(bb, cs.GetNumberOfPoints());
vtkmdiy::save(
bb, cs.GetShapesArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
vtkmdiy::save(
bb, cs.GetNumIndicesArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
vtkmdiy::save(
bb, cs.GetConnectivityArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
diy::save(
vtkmdiy::save(
bb, cs.GetIndexOffsetArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
vtkm::Id numberOfPoints = 0;
diy::load(bb, numberOfPoints);
vtkmdiy::load(bb, numberOfPoints);
vtkm::cont::ArrayHandle<vtkm::UInt8, ShapeST> shapes;
diy::load(bb, shapes);
vtkmdiy::load(bb, shapes);
vtkm::cont::ArrayHandle<vtkm::IdComponent, CountST> counts;
diy::load(bb, counts);
vtkmdiy::load(bb, counts);
vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST> connectivity;
diy::load(bb, connectivity);
vtkmdiy::load(bb, connectivity);
vtkm::cont::ArrayHandle<vtkm::Id, OffsetST> offsets;
diy::load(bb, offsets);
vtkmdiy::load(bb, offsets);
cs = Type(name);
cs.Fill(numberOfPoints, shapes, counts, connectivity, offsets);

14
vtkm/cont/CellSetPermutation.h
View File

@ -414,7 +414,7 @@ struct TypeString<vtkm::cont::CellSetPermutation<CSType, AHValidCellIds>>
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename CSType, typename AHValidCellIds>
@ -426,19 +426,19 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetFullCellSet());
diy::save(bb, cs.GetValidCellIds());
vtkmdiy::save(bb, cs.GetName());
vtkmdiy::save(bb, cs.GetFullCellSet());
vtkmdiy::save(bb, cs.GetValidCellIds());
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
CSType fullCS;
diy::load(bb, fullCS);
vtkmdiy::load(bb, fullCS);
AHValidCellIds validCellIds;
diy::load(bb, validCellIds);
vtkmdiy::load(bb, validCellIds);
cs = make_CellSetPermutation(validCellIds, fullCS, name);
}

22
vtkm/cont/CellSetSingleType.h
View File

@ -282,7 +282,7 @@ struct TypeString<vtkm::cont::CellSetSingleType<ConnectivityST>>
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename ConnectivityST>
@ -294,26 +294,26 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetNumberOfPoints());
diy::save(bb, cs.GetCellShape(0));
diy::save(bb, cs.GetNumberOfPointsInCell(0));
diy::save(
vtkmdiy::save(bb, cs.GetName());
vtkmdiy::save(bb, cs.GetNumberOfPoints());
vtkmdiy::save(bb, cs.GetCellShape(0));
vtkmdiy::save(bb, cs.GetNumberOfPointsInCell(0));
vtkmdiy::save(
bb, cs.GetConnectivityArray(vtkm::TopologyElementTagPoint{}, vtkm::TopologyElementTagCell{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
vtkm::Id numberOfPoints = 0;
diy::load(bb, numberOfPoints);
vtkmdiy::load(bb, numberOfPoints);
vtkm::UInt8 shape;
diy::load(bb, shape);
vtkmdiy::load(bb, shape);
vtkm::IdComponent count;
diy::load(bb, count);
vtkmdiy::load(bb, count);
vtkm::cont::ArrayHandle<vtkm::Id, ConnectivityST> connectivity;
diy::load(bb, connectivity);
vtkmdiy::load(bb, connectivity);
cs = Type(name);
cs.Fill(numberOfPoints, shape, count, connectivity);

14
vtkm/cont/CellSetStructured.h
View File

@ -143,7 +143,7 @@ struct TypeString<vtkm::cont::CellSetStructured<DIMENSION>>
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <vtkm::IdComponent DIMENSION>
@ -155,18 +155,18 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetPointDimensions());
diy::save(bb, cs.GetGlobalPointIndexStart());
vtkmdiy::save(bb, cs.GetName());
vtkmdiy::save(bb, cs.GetPointDimensions());
vtkmdiy::save(bb, cs.GetGlobalPointIndexStart());
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& cs)
{
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
typename Type::SchedulingRangeType dims, start;
diy::load(bb, dims);
diy::load(bb, start);
vtkmdiy::load(bb, dims);
vtkmdiy::load(bb, start);
cs = Type(name);
cs.SetPointDimensions(dims);

10
vtkm/cont/CoordinateSystem.h
View File

@ -143,7 +143,7 @@ struct DynamicTransformTraits<vtkm::cont::CoordinateSystem>
//=============================================================================
// Specializations of serialization related classes
namespace diy
namespace mangled_diy_namespace
{
template <>
@ -151,16 +151,16 @@ struct Serialization<vtkm::cont::CoordinateSystem>
{
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::CoordinateSystem& cs)
{
diy::save(bb, cs.GetName());
diy::save(bb, cs.GetData());
vtkmdiy::save(bb, cs.GetName());
vtkmdiy::save(bb, cs.GetData());
}
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::CoordinateSystem& cs)
{
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
vtkm::cont::ArrayHandleVirtualCoordinates array;
diy::load(bb, array);
vtkmdiy::load(bb, array);
cs = vtkm::cont::CoordinateSystem(name, array);
}
};

26
vtkm/cont/DataSet.h
View File

@ -208,7 +208,7 @@ struct SerializableDataSet
}
} // vtkm::cont
namespace diy
namespace mangled_diy_namespace
{
template <typename FieldTypeList, typename CellSetTypesList>
@ -223,24 +223,24 @@ public:
const auto& dataset = serializable.DataSet;
vtkm::IdComponent numberOfCoordinateSystems = dataset.GetNumberOfCoordinateSystems();
diy::save(bb, numberOfCoordinateSystems);
vtkmdiy::save(bb, numberOfCoordinateSystems);
for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
{
diy::save(bb, dataset.GetCoordinateSystem(i));
vtkmdiy::save(bb, dataset.GetCoordinateSystem(i));
}
vtkm::IdComponent numberOfCellSets = dataset.GetNumberOfCellSets();
diy::save(bb, numberOfCellSets);
vtkmdiy::save(bb, numberOfCellSets);
for (vtkm::IdComponent i = 0; i < numberOfCellSets; ++i)
{
diy::save(bb, dataset.GetCellSet(i).ResetCellSetList(CellSetTypesList{}));
vtkmdiy::save(bb, dataset.GetCellSet(i).ResetCellSetList(CellSetTypesList{}));
}
vtkm::IdComponent numberOfFields = dataset.GetNumberOfFields();
diy::save(bb, numberOfFields);
vtkmdiy::save(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
diy::save(bb, vtkm::cont::SerializableField<FieldTypeList>(dataset.GetField(i)));
vtkmdiy::save(bb, vtkm::cont::SerializableField<FieldTypeList>(dataset.GetField(i)));
}
}
@ -250,29 +250,29 @@ public:
dataset = {}; // clear
vtkm::IdComponent numberOfCoordinateSystems = 0;
diy::load(bb, numberOfCoordinateSystems);
vtkmdiy::load(bb, numberOfCoordinateSystems);
for (vtkm::IdComponent i = 0; i < numberOfCoordinateSystems; ++i)
{
vtkm::cont::CoordinateSystem coords;
diy::load(bb, coords);
vtkmdiy::load(bb, coords);
dataset.AddCoordinateSystem(coords);
}
vtkm::IdComponent numberOfCellSets = 0;
diy::load(bb, numberOfCellSets);
vtkmdiy::load(bb, numberOfCellSets);
for (vtkm::IdComponent i = 0; i < numberOfCellSets; ++i)
{
vtkm::cont::DynamicCellSetBase<CellSetTypesList> cells;
diy::load(bb, cells);
vtkmdiy::load(bb, cells);
dataset.AddCellSet(vtkm::cont::DynamicCellSet(cells));
}
vtkm::IdComponent numberOfFields = 0;
diy::load(bb, numberOfFields);
vtkmdiy::load(bb, numberOfFields);
for (vtkm::IdComponent i = 0; i < numberOfFields; ++i)
{
vtkm::cont::SerializableField<FieldTypeList> field;
diy::load(bb, field);
vtkmdiy::load(bb, field);
dataset.AddField(field.Field);
}
}

62
vtkm/cont/DeviceAdapterAlgorithm.h
View File

@ -22,6 +22,7 @@
#include <vtkm/Types.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/internal/ArrayManagerExecution.h>
#include <vtkm/cont/internal/DeviceAdapterTag.h>
@ -539,6 +540,11 @@ template <class DeviceAdapterTag>
class DeviceAdapterTimerImplementation
{
public:
struct TimeStamp
{
vtkm::Int64 Seconds;
vtkm::Int64 Microseconds;
};
/// When a timer is constructed, all threads are synchronized and the
/// current time is marked so that GetElapsedTime returns the number of
/// seconds elapsed since the construction.
@ -548,7 +554,30 @@ public:
/// number of seconds elapsed since the call to this. This method
/// synchronizes all asynchronous operations.
///
VTKM_CONT void Reset() { this->StartTime = this->GetCurrentTime(); }
VTKM_CONT void Reset()
{
this->StartReady = false;
this->StopReady = false;
}
VTKM_CONT void Start()
{
this->Reset();
this->StartTime = this->GetCurrentTime();
this->StartReady = true;
}
VTKM_CONT void Stop()
{
this->StopTime = this->GetCurrentTime();
this->StopReady = true;
}
VTKM_CONT bool Started() { return this->StartReady; }
VTKM_CONT bool Stopped() { return this->StopReady; }
VTKM_CONT bool Ready() { return true; }
/// Returns the elapsed time in seconds between the construction of this
/// class or the last call to Reset and the time this function is called. The
@ -558,21 +587,29 @@ public:
///
VTKM_CONT vtkm::Float64 GetElapsedTime()
{
TimeStamp currentTime = this->GetCurrentTime();
assert(this->StartReady);
if (!this->StartReady)
{
VTKM_LOG_S(vtkm::cont::LogLevel::Error,
"Start() function should be called first then trying to call GetElapsedTime().");
return 0;
}
bool manualStop = true;
if (!this->StopReady)
{
manualStop = false;
this->Stop();
}
vtkm::Float64 elapsedTime;
elapsedTime = vtkm::Float64(currentTime.Seconds - this->StartTime.Seconds);
elapsedTime += (vtkm::Float64(currentTime.Microseconds - this->StartTime.Microseconds) /
elapsedTime = vtkm::Float64(this->StopTime.Seconds - this->StartTime.Seconds);
elapsedTime += (vtkm::Float64(this->StopTime.Microseconds - this->StartTime.Microseconds) /
vtkm::Float64(1000000));
// Reset StopReady flag to its original state
this->StopReady = manualStop;
return elapsedTime;
}
struct TimeStamp
{
vtkm::Int64 Seconds;
vtkm::Int64 Microseconds;
};
TimeStamp StartTime;
VTKM_CONT TimeStamp GetCurrentTime()
{
@ -592,6 +629,11 @@ public:
#endif
return retval;
}
bool StartReady;
bool StopReady;
TimeStamp StartTime;
TimeStamp StopTime;
};
/// \brief Class providing a device-specific runtime support detector.

10
vtkm/cont/DynamicCellSet.h
View File

@ -364,7 +364,7 @@ struct DynamicCellSetCheck<vtkm::cont::DynamicCellSetBase<CellSetList>>
//=============================================================================
// Specializations of serialization related classes
namespace diy
namespace mangled_diy_namespace
{
namespace internal
@ -375,8 +375,8 @@ struct DynamicCellSetSerializeFunctor
template <typename CellSetType>
void operator()(const CellSetType& cs, BinaryBuffer& bb) const
{
diy::save(bb, vtkm::cont::TypeString<CellSetType>::Get());
diy::save(bb, cs);
vtkmdiy::save(bb, vtkm::cont::TypeString<CellSetType>::Get());
vtkmdiy::save(bb, cs);
}
};
@ -393,7 +393,7 @@ struct DynamicCellSetDeserializeFunctor
if (!success && (typeString == vtkm::cont::TypeString<CellSetType>::Get()))
{
CellSetType cs;
diy::load(bb, cs);
vtkmdiy::load(bb, cs);
dh = vtkm::cont::DynamicCellSetBase<CellSetTypes>(cs);
success = true;
}
@ -417,7 +417,7 @@ public:
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
std::string typeString;
diy::load(bb, typeString);
vtkmdiy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(internal::DynamicCellSetDeserializeFunctor<CellSetTypes>{},

16
vtkm/cont/EnvironmentTracker.cxx
View File

@ -19,11 +19,7 @@
//============================================================================
#include <vtkm/cont/EnvironmentTracker.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
namespace vtkm
{
@ -31,17 +27,17 @@ namespace cont
{
namespace internal
{
static diy::mpi::communicator GlobalCommuncator(MPI_COMM_NULL);
static vtkmdiy::mpi::communicator GlobalCommuncator(MPI_COMM_NULL);
}
void EnvironmentTracker::SetCommunicator(const diy::mpi::communicator& comm)
void EnvironmentTracker::SetCommunicator(const vtkmdiy::mpi::communicator& comm)
{
vtkm::cont::internal::GlobalCommuncator = comm;
}
const diy::mpi::communicator& EnvironmentTracker::GetCommunicator()
const vtkmdiy::mpi::communicator& EnvironmentTracker::GetCommunicator()
{
#ifndef DIY_NO_MPI
#ifndef VTKM_DIY_NO_MPI
int flag;
MPI_Initialized(&flag);
if (!flag)
@ -49,7 +45,7 @@ const diy::mpi::communicator& EnvironmentTracker::GetCommunicator()
int argc = 0;
char** argv = nullptr;
MPI_Init(&argc, &argv);
internal::GlobalCommuncator = diy::mpi::communicator(MPI_COMM_WORLD);
internal::GlobalCommuncator = vtkmdiy::mpi::communicator(MPI_COMM_WORLD);
}
#endif
return vtkm::cont::internal::GlobalCommuncator;

13
vtkm/cont/EnvironmentTracker.h
View File

@ -23,15 +23,8 @@
#include <vtkm/Types.h>
#include <vtkm/cont/vtkm_cont_export.h>
#include <vtkm/internal/ExportMacros.h>
#include <vtkm/thirdparty/diy/Configure.h>
namespace diy
{
namespace mpi
{
class communicator;
}
}
#include <vtkm/thirdparty/diy/diy.h>
namespace vtkm
{
@ -46,10 +39,10 @@ class VTKM_CONT_EXPORT EnvironmentTracker
{
public:
VTKM_CONT
static void SetCommunicator(const diy::mpi::communicator& comm);
static void SetCommunicator(const vtkmdiy::mpi::communicator& comm);
VTKM_CONT
static const diy::mpi::communicator& GetCommunicator();
static const vtkmdiy::mpi::communicator& GetCommunicator();
};
}
}

2
vtkm/cont/ErrorBadType.h
View File

@ -36,7 +36,7 @@ class VTKM_ALWAYS_EXPORT ErrorBadType : public Error
{
public:
ErrorBadType(const std::string& message)
: Error(message)
: Error(message, true)
{
}
};

26
vtkm/cont/Field.h
View File

@ -321,7 +321,7 @@ struct SerializableField
} // namespace cont
} // namespace vtkm
namespace diy
namespace mangled_diy_namespace
{
template <typename TypeList>
@ -335,17 +335,17 @@ public:
{
const auto& field = serializable.Field;
diy::save(bb, field.GetName());
diy::save(bb, static_cast<int>(field.GetAssociation()));
vtkmdiy::save(bb, field.GetName());
vtkmdiy::save(bb, static_cast<int>(field.GetAssociation()));
if (field.GetAssociation() == vtkm::cont::Field::Association::CELL_SET)
{
diy::save(bb, field.GetAssocCellSet());
vtkmdiy::save(bb, field.GetAssocCellSet());
}
else if (field.GetAssociation() == vtkm::cont::Field::Association::LOGICAL_DIM)
{
diy::save(bb, field.GetAssocLogicalDim());
vtkmdiy::save(bb, field.GetAssocLogicalDim());
}
diy::save(bb, field.GetData().ResetTypes(TypeList{}));
vtkmdiy::save(bb, field.GetData().ResetTypes(TypeList{}));
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& serializable)
@ -353,30 +353,30 @@ public:
auto& field = serializable.Field;
std::string name;
diy::load(bb, name);
vtkmdiy::load(bb, name);
int assocVal = 0;
diy::load(bb, assocVal);
vtkmdiy::load(bb, assocVal);
auto assoc = static_cast<vtkm::cont::Field::Association>(assocVal);
vtkm::cont::VariantArrayHandleBase<TypeList> data;
if (assoc == vtkm::cont::Field::Association::CELL_SET)
{
std::string assocCellSetName;
diy::load(bb, assocCellSetName);
diy::load(bb, data);
vtkmdiy::load(bb, assocCellSetName);
vtkmdiy::load(bb, data);
field =
vtkm::cont::Field(name, assoc, assocCellSetName, vtkm::cont::VariantArrayHandle(data));
}
else if (assoc == vtkm::cont::Field::Association::LOGICAL_DIM)
{
vtkm::IdComponent assocLogicalDim;
diy::load(bb, assocLogicalDim);
diy::load(bb, data);
vtkmdiy::load(bb, assocLogicalDim);
vtkmdiy::load(bb, data);
field = vtkm::cont::Field(name, assoc, assocLogicalDim, vtkm::cont::VariantArrayHandle(data));
}
else
{
diy::load(bb, data);
vtkmdiy::load(bb, data);
field = vtkm::cont::Field(name, assoc, vtkm::cont::VariantArrayHandle(data));
}
}

85
vtkm/cont/FieldRangeGlobalCompute.cxx
View File

@ -21,15 +21,7 @@
#include <vtkm/cont/EnvironmentTracker.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/Configure.h>
#include VTKM_DIY(diy/decomposition.hpp)
#include VTKM_DIY(diy/master.hpp)
#include VTKM_DIY(diy/partners/all-reduce.hpp)
#include VTKM_DIY(diy/reduce.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <vtkm/thirdparty/diy/diy.h>
#include <algorithm>
#include <functional>
@ -78,56 +70,57 @@ vtkm::cont::ArrayHandle<vtkm::Range> MergeRangesGlobal(
using VectorOfRangesT = std::vector<vtkm::Range>;
diy::Master master(comm,
1,
-1,
[]() -> void* { return new VectorOfRangesT(); },
[](void* ptr) { delete static_cast<VectorOfRangesT*>(ptr); });
vtkmdiy::Master master(comm,
1,
-1,
[]() -> void* { return new VectorOfRangesT(); },
[](void* ptr) { delete static_cast<VectorOfRangesT*>(ptr); });
diy::ContiguousAssigner assigner(/*num ranks*/ comm.size(), /*global-num-blocks*/ comm.size());
diy::RegularDecomposer<diy::DiscreteBounds> decomposer(
/*dim*/ 1, diy::interval(0, comm.size() - 1), comm.size());
vtkmdiy::ContiguousAssigner assigner(/*num ranks*/ comm.size(),
/*global-num-blocks*/ comm.size());
vtkmdiy::RegularDecomposer<vtkmdiy::DiscreteBounds> decomposer(
/*dim*/ 1, vtkmdiy::interval(0, comm.size() - 1), comm.size());
decomposer.decompose(comm.rank(), assigner, master);
assert(master.size() == 1); // each rank will have exactly 1 block.
*master.block<VectorOfRangesT>(0) = v_ranges;
diy::RegularAllReducePartners all_reduce_partners(decomposer, /*k*/ 2);
vtkmdiy::RegularAllReducePartners all_reduce_partners(decomposer, /*k*/ 2);
auto callback =
[](VectorOfRangesT* data, const diy::ReduceProxy& srp, const diy::RegularMergePartners&) {
const auto selfid = srp.gid();
// 1. dequeue.
std::vector<int> incoming;
srp.incoming(incoming);
for (const int gid : incoming)
auto callback = [](
VectorOfRangesT* data, const vtkmdiy::ReduceProxy& srp, const vtkmdiy::RegularMergePartners&) {
const auto selfid = srp.gid();
// 1. dequeue.
std::vector<int> incoming;
srp.incoming(incoming);
for (const int gid : incoming)
{
if (gid != selfid)
{
if (gid != selfid)
{
VectorOfRangesT message;
srp.dequeue(gid, message);
VectorOfRangesT message;
srp.dequeue(gid, message);
// if the number of components we've seen so far is less than those
// in the received message, resize so we can accommodate all components
// in the message. If the message has fewer components, it has no
// effect.
data->resize(std::max(data->size(), message.size()));
// if the number of components we've seen so far is less than those
// in the received message, resize so we can accommodate all components
// in the message. If the message has fewer components, it has no
// effect.
data->resize(std::max(data->size(), message.size()));
std::transform(
message.begin(), message.end(), data->begin(), data->begin(), std::plus<vtkm::Range>());
}
std::transform(
message.begin(), message.end(), data->begin(), data->begin(), std::plus<vtkm::Range>());
}
// 2. enqueue
for (int cc = 0; cc < srp.out_link().size(); ++cc)
}
// 2. enqueue
for (int cc = 0; cc < srp.out_link().size(); ++cc)
{
auto target = srp.out_link().target(cc);
if (target.gid != selfid)
{
auto target = srp.out_link().target(cc);
if (target.gid != selfid)
{
srp.enqueue(target, *data);
}
srp.enqueue(target, *data);
}
};
}
};
diy::reduce(master, assigner, all_reduce_partners, callback);
vtkmdiy::reduce(master, assigner, all_reduce_partners, callback);
assert(master.size() == 1); // each rank will have exactly 1 block.
return vtkm::cont::make_ArrayHandle(*master.block<VectorOfRangesT>(0), vtkm::CopyFlag::On);

6
vtkm/cont/Serialization.h
View File

@ -22,10 +22,6 @@
#include <vtkm/cont/TypeString.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/Configure.h>
#include VTKM_DIY(diy/serialization.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
#include <vtkm/thirdparty/diy/serialization.h>
#endif // vtk_m_cont_Serialization_h

254
vtkm/cont/Timer.cxx Normal file
View File

@ -0,0 +1,254 @@
//============================================================================
// 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 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// 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/Logging.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/internal/brigand.hpp>
namespace vtkm
{
namespace cont
{
namespace detail
{
template <typename State, typename T>
struct RemoveDisabledDevice
{
using type = typename std::conditional<T::IsEnabled, brigand::push_back<State, T>, State>::type;
};
/// TMP code to generate enabled device timer container
using AllDeviceList = DeviceAdapterListTagCommon::list;
using EnabledDeviceList =
brigand::fold<AllDeviceList,
brigand::list<>,
detail::RemoveDisabledDevice<brigand::_state, brigand::_element>>;
struct EnabledDeviceListTag : vtkm::ListTagBase<>
{
using list = EnabledDeviceList;
};
using EnabledTimerImpls =
brigand::transform<EnabledDeviceList,
brigand::bind<DeviceAdapterTimerImplementation, brigand::_1>>;
using EnabledTimerImplTuple = brigand::as_tuple<EnabledTimerImpls>;
}
enum class TimerDispatchTag : int
{
Reset,
Start,
Stop,
Started,
Stopped,
Ready,
GetElapsedTime
};
class EnabledDeviceTimerImpls
{
public:
EnabledDeviceTimerImpls() {}
~EnabledDeviceTimerImpls() {}
// A tuple of enabled timer implementations
detail::EnabledTimerImplTuple timerImplTuple;
};
namespace detail
{
// C++11 does not support get tuple element by type. C++14 does support that.
// Get the index of a type in tuple elements
template <class T, class Tuple>
struct Index;
template <class T, template <typename...> class Container, class... Types>
struct Index<T, Container<T, Types...>>
{
static const std::size_t value = 0;
};
template <class T, class U, template <typename...> class Container, class... Types>
struct Index<T, Container<U, Types...>>
{
static const std::size_t value = 1 + Index<T, Container<Types...>>::value;
};
struct TimerFunctor
{
TimerFunctor()
: elapsedTime(0)
, value(true)
{
}
template <typename DeviceAdapter>
VTKM_CONT void operator()(DeviceAdapter device, Timer* timer, TimerDispatchTag tag)
{
if (timer->Device == device || timer->Device == DeviceAdapterTagAny())
{
auto& timerImpl = std::get<Index<DeviceAdapter, detail::EnabledDeviceList>::value>(
timer->Internal->timerImplTuple);
switch (tag)
{
case TimerDispatchTag::Reset:
timerImpl.Reset();
break;
case TimerDispatchTag::Start:
timerImpl.Start();
break;
case TimerDispatchTag::Stop:
timerImpl.Stop();
break;
case TimerDispatchTag::Started:
value &= timerImpl.Started();
break;
case TimerDispatchTag::Stopped:
value &= timerImpl.Stopped();
break;
case TimerDispatchTag::Ready:
value &= timerImpl.Ready();
break;
case TimerDispatchTag::GetElapsedTime:
{
if (timer->Device == DeviceAdapterTagAny() &&
timer->DeviceForQuery == DeviceAdapterTagAny())
{ // Just want to do timing jobs
elapsedTime = std::max(elapsedTime, timerImpl.GetElapsedTime());
break;
}
else if (timer->Device == DeviceAdapterTagAny() && timer->DeviceForQuery == device)
{ // Given a generic timer, querying for a specific device time
elapsedTime = timerImpl.GetElapsedTime();
break;
}
else if (timer->Device == device && (timer->DeviceForQuery == DeviceAdapterTagAny() ||
timer->Device == timer->DeviceForQuery))
{ // Given a specific timer, querying its elapsed time
elapsedTime = timerImpl.GetElapsedTime();
break;
}
break;
}
}
}
}
vtkm::Float64 elapsedTime;
bool value;
};
}
Timer::Timer()
: Device(vtkm::cont::DeviceAdapterTagAny())
, DeviceForQuery(vtkm::cont::DeviceAdapterTagAny())
, Internal(nullptr)
{
this->Init();
}
Timer::~Timer()
{
delete this->Internal;
}
void Timer::Init()
{
if (!this->Internal)
{
this->Internal = new EnabledDeviceTimerImpls();
}
}
void Timer::Reset()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Reset);
}
void Timer::Start()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Start);
}
void Timer::Stop()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Stop);
}
bool Timer::Started()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Started);
return functor.value;
}
bool Timer::Stopped()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Stopped);
return functor.value;
}
bool Timer::Ready()
{
detail::TimerFunctor functor;
vtkm::ListForEach(functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::Ready);
return functor.value;
}
vtkm::Float64 Timer::GetElapsedTime(DeviceAdapterId id)
{
// Timer is constructed with a specific device. Only querying this device is allowed.
if (this->Device != DeviceAdapterTagAny() && (id != DeviceAdapterTagAny() && this->Device != id))
{
VTKM_LOG_S(vtkm::cont::LogLevel::Error,
"Device '" << id.GetName() << "' is not supported for current timer"
<< "("
<< this->Device.GetName()
<< ")");
return 0.0;
}
// Timer is constructed with any device. Only querying enabled device is allowed.
vtkm::cont::RuntimeDeviceTracker tracker;
if (this->Device == DeviceAdapterTagAny() &&
(id != DeviceAdapterTagAny() && !tracker.CanRunOn(id)))
{
VTKM_LOG_S(vtkm::cont::LogLevel::Error,
"Device '" << id.GetName() << "' can not run on current Device."
"Thus timer is not usable");
return 0.0;
}
this->DeviceForQuery = id;
detail::TimerFunctor functor;
vtkm::ListForEach(
functor, detail::EnabledDeviceListTag(), this, TimerDispatchTag::GetElapsedTime);
return functor.elapsedTime;
}
}
} // namespace vtkm::cont

83
vtkm/cont/Timer.h
View File

@ -20,56 +20,85 @@
#ifndef vtk_m_cont_Timer_h
#define vtk_m_cont_Timer_h
#include <vtkm/ListTag.h>
#include <vtkm/cont/DeviceAdapter.h>
#include <vtkm/cont/DeviceAdapterListTag.h>
#include <vtkm/cont/vtkm_cont_export.h>
namespace vtkm
{
namespace cont
{
namespace detail
{
struct TimerFunctor;
}
class EnabledDeviceTimerImpls;
/// A class that can be used to time operations in VTK-m that might be occurring
/// in parallel. You should make sure that the device adapter for the timer
/// matches that being used to execute algorithms to ensure that the thread
/// synchronization is correct.
/// A class that can be used to time operations in VTK-m that might be occuring
/// in parallel. Users are recommended to provide a device adapter at construction
/// time which matches the one being used to execute algorithms to ensure that thread
/// synchronization is correct and accurate.
/// If no device adapter is provided at construction time, the maximum
/// elapsed time of all enabled deivces will be returned. Normally cuda is expected to
/// have the longest execution time if enabled.
/// Per device adapter time query is also supported. It's useful when users want to reuse
/// the same timer to measure the cuda kernal call as well as the cuda device execution.
///
/// The there is no guaranteed resolution of the time but should generally be
/// good to about a millisecond.
///
template <class Device = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
class Timer
class VTKM_CONT_EXPORT Timer
{
friend struct detail::TimerFunctor;
public:
/// When a timer is constructed, all threads are synchronized and the
/// current time is marked so that GetElapsedTime returns the number of
/// seconds elapsed since the construction.
VTKM_CONT
Timer()
: TimerImplementation()
Timer();
template <typename DeviceAdapter>
VTKM_CONT Timer(DeviceAdapter id)
: Device(id)
, DeviceForQuery(DeviceAdapterTagAny())
, Internal(nullptr)
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapter);
static_assert(DeviceAdapter::IsEnabled, "A disabled device is passed to the Timer");
this->Init();
}
/// Resets the timer. All further calls to GetElapsedTime will report the
/// number of seconds elapsed since the call to this. This method
/// synchronizes all asynchronous operations.
///
VTKM_CONT
void Reset() { this->TimerImplementation.Reset(); }
VTKM_CONT ~Timer();
/// Returns the elapsed time in seconds between the construction of this
/// class or the last call to Reset and the time this function is called. The
/// time returned is measured in wall time. GetElapsedTime may be called any
/// number of times to get the progressive time. This method synchronizes all
/// asynchronous operations.
///
/// Resets the timer.
VTKM_CONT void Reset();
/// Start would call Reset function before starting the timer for convenience
VTKM_CONT void Start();
VTKM_CONT void Stop();
VTKM_CONT bool Started();
VTKM_CONT bool Stopped();
/// Used to check if Timer has finished the synchronization to get the result from the device.
VTKM_CONT bool Ready();
/// Get the elapsed time measured by the given device adapter. If no device is
/// specified, the max time of all device measurements will be returned.
VTKM_CONT
vtkm::Float64 GetElapsedTime() { return this->TimerImplementation.GetElapsedTime(); }
vtkm::Float64 GetElapsedTime(DeviceAdapterId id = DeviceAdapterTagAny());
private:
VTKM_CONT void Init();
/// Some timers are ill-defined when copied, so disallow that for all timers.
VTKM_CONT Timer(const Timer<Device>&) = delete;
VTKM_CONT void operator=(const Timer<Device>&) = delete;
VTKM_CONT Timer(const Timer&) = delete;
VTKM_CONT void operator=(const Timer&) = delete;
vtkm::cont::DeviceAdapterTimerImplementation<Device> TimerImplementation;
DeviceAdapterId Device;
DeviceAdapterId DeviceForQuery;
EnabledDeviceTimerImpls* Internal;
};
}
} // namespace vtkm::cont

10
vtkm/cont/VariantArrayHandle.h
View File

@ -434,7 +434,7 @@ struct DynamicTransformTraits<vtkm::cont::VariantArrayHandleBase<TypeList>>
//=============================================================================
// Specializations of serialization related classes
namespace diy
namespace mangled_diy_namespace
{
namespace internal
@ -445,8 +445,8 @@ struct VariantArrayHandleSerializeFunctor
template <typename ArrayHandleType>
void operator()(const ArrayHandleType& ah, BinaryBuffer& bb) const
{
diy::save(bb, vtkm::cont::TypeString<ArrayHandleType>::Get());
diy::save(bb, ah);
vtkmdiy::save(bb, vtkm::cont::TypeString<ArrayHandleType>::Get());
vtkmdiy::save(bb, ah);
}
};
@ -464,7 +464,7 @@ struct VariantArrayHandleDeserializeFunctor
if (!success && (typeString == vtkm::cont::TypeString<ArrayHandleType>::Get()))
{
ArrayHandleType ah;
diy::load(bb, ah);
vtkmdiy::load(bb, ah);
dh = vtkm::cont::VariantArrayHandleBase<TypeList>(ah);
success = true;
}
@ -488,7 +488,7 @@ public:
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
std::string typeString;
diy::load(bb, typeString);
vtkmdiy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(

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

@ -26,7 +26,7 @@ set(headers
#-----------------------------------------------------------------------------
add_subdirectory(internal)
vtkm_declare_headers(CUDA ${headers})
vtkm_declare_headers(${headers})
#-----------------------------------------------------------------------------
if (TARGET vtkm::cuda)

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

@ -33,7 +33,7 @@ set(headers
VirtualObjectTransferCuda.h
)
vtkm_declare_headers(CUDA ${headers})
vtkm_declare_headers(${headers})
if (TARGET vtkm::cuda)

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

@ -61,7 +61,7 @@ public:
// We work around this by calling the __device__ function inside of a
// __CUDA_ARCH__ guard, as nvcc is smart enough to recognize that this is a
// safe usage of a __device__ function in a __host__ __device__ context.
#ifdef __CUDA_ARCH__
#ifdef VTKM_CUDA_DEVICE_PASS
T* lockedValue = ::thrust::raw_pointer_cast(this->Portal.GetIteratorBegin() + index);
return this->vtkmAtomicAdd(lockedValue, value);
#else
@ -85,7 +85,7 @@ public:
// We work around this by calling the __device__ function inside of a
// __CUDA_ARCH__ guard, as nvcc is smart enough to recognize that this is a
// safe usage of a __device__ function in a __host__ __device__ context.
#ifdef __CUDA_ARCH__
#ifdef VTKM_CUDA_DEVICE_PASS
T* lockedValue = ::thrust::raw_pointer_cast(this->Portal.GetIteratorBegin() + index);
return this->vtkmCompareAndSwap(lockedValue, newValue, oldValue);
#else

45
vtkm/cont/cuda/internal/DeviceAdapterRuntimeDetectorCuda.cxx
View File

@ -27,24 +27,6 @@
#include <vtkm/Math.h>
#include <vtkm/cont/cuda/ErrorCuda.h>
namespace vtkm
{
namespace cont
{
namespace cuda
{
namespace internal
{
static __global__ void DetermineIfValidCudaDevice()
{
//used only to see if we can launch kernels. It is possible to have a
//CUDA capable device, but still fail to have CUDA support.
}
}
}
}
}
namespace
{
static std::once_flag deviceQueryFlag;
@ -64,28 +46,11 @@ void queryNumberOfDevicesandHighestArchSupported(vtkm::Int32& nod, vtkm::Int32&
for (vtkm::Int32 i = 0; i < numDevices; i++)
{
cudaDeviceProp prop;
VTKM_CUDA_CALL(cudaGetDeviceProperties(&prop, i));
const vtkm::Int32 arch = (prop.major * 10) + prop.minor;
archVersion = vtkm::Max(arch, archVersion);
}
//Make sure we can actually launch a kernel. This could fail for any
//of the following reasons:
//
// 1. cudaErrorInsufficientDriver, caused by out of data drives
// 2. cudaErrorDevicesUnavailable, caused by another process locking the
// device or somebody disabling cuda support on the device
// 3. cudaErrorNoKernelImageForDevice we built for a compute version
// greater than the device we are running on
// Most likely others that I don't even know about
if (numDevices > 0)
{
vtkm::cont::cuda::internal::DetermineIfValidCudaDevice<<<1, 1, 0, cudaStreamPerThread>>>();
cudaStreamSynchronize(cudaStreamPerThread);
if (cudaSuccess != cudaGetLastError())
res = cudaGetDeviceProperties(&prop, i);
if (res == cudaSuccess)
{
numDevices = 0;
archVersion = 0;
const vtkm::Int32 arch = (prop.major * 10) + prop.minor;
archVersion = vtkm::Max(arch, archVersion);
}
}
});
@ -112,7 +77,7 @@ DeviceAdapterRuntimeDetector<vtkm::cont::DeviceAdapterTagCuda>::DeviceAdapterRun
bool DeviceAdapterRuntimeDetector<vtkm::cont::DeviceAdapterTagCuda>::Exists() const
{
return this->NumberOfDevices > 0 && this->HighestArchSupported >= 20;
return this->NumberOfDevices > 0 && this->HighestArchSupported >= 30;
}
}
} // namespace vtkm::cont

61
vtkm/cont/cuda/internal/DeviceAdapterTimerImplementationCuda.cu
View File

@ -33,7 +33,7 @@ DeviceAdapterTimerImplementation<
vtkm::cont::DeviceAdapterTagCuda>::DeviceAdapterTimerImplementation()
{
VTKM_CUDA_CALL(cudaEventCreate(&this->StartEvent));
VTKM_CUDA_CALL(cudaEventCreate(&this->EndEvent));
VTKM_CUDA_CALL(cudaEventCreate(&this->StopEvent));
this->Reset();
}
@ -45,21 +45,72 @@ DeviceAdapterTimerImplementation<
// VTKM_CUDA_CHECK_ASYNCHRONOUS_ERROR catching any issues from these calls
// later.
cudaEventDestroy(this->StartEvent);
cudaEventDestroy(this->EndEvent);
cudaEventDestroy(this->StopEvent);
}
void DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Reset()
{
this->StartReady = false;
this->StopReady = false;
}
void DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Start()
{
VTKM_CUDA_CALL(cudaEventRecord(this->StartEvent, cudaStreamPerThread));
VTKM_CUDA_CALL(cudaEventSynchronize(this->StartEvent));
this->StartReady = true;
}
void DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Stop()
{
VTKM_CUDA_CALL(cudaEventRecord(this->StopEvent, cudaStreamPerThread));
this->StopReady = true;
}
bool DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Started()
{
return this->StartReady;
}
bool DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Stopped()
{
return this->StopReady;
}
// Callbacks without a mandated order(in independent streams) execute in undefined
// order and maybe serialized. So Instead CudaEventQuery is used here.
// Ref link: https://docs.nvidia.com/cuda/cuda-driver-api/group__CUDA__STREAM.html
bool DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::Ready()
{
if (cudaEventQuery(this->StopEvent) == cudaSuccess)
{
return true;
}
return false;
}
vtkm::Float64 DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>::GetElapsedTime()
{
VTKM_CUDA_CALL(cudaEventRecord(this->EndEvent, cudaStreamPerThread));
VTKM_CUDA_CALL(cudaEventSynchronize(this->EndEvent));
assert(this->StartReady);
if (!this->StartReady)
{
VTKM_LOG_F(vtkm::cont::LogLevel::Error,
"Start() function should be called first then trying to call GetElapsedTime().");
return 0;
}
bool manualStop = true;
if (!this->StopReady)
{
manualStop = false;
this->Stop();
}
VTKM_CUDA_CALL(cudaEventSynchronize(this->StopEvent));
float elapsedTimeMilliseconds;
VTKM_CUDA_CALL(cudaEventElapsedTime(&elapsedTimeMilliseconds, this->StartEvent, this->EndEvent));
VTKM_CUDA_CALL(cudaEventElapsedTime(&elapsedTimeMilliseconds, this->StartEvent, this->StopEvent));
// Reset Stop flag to its original state
this->StopReady = manualStop;
return static_cast<vtkm::Float64>(0.001f * elapsedTimeMilliseconds);
}
}

14
vtkm/cont/cuda/internal/DeviceAdapterTimerImplementationCuda.h
View File

@ -50,6 +50,16 @@ public:
VTKM_CONT void Reset();
VTKM_CONT void Start();
VTKM_CONT void Stop();
VTKM_CONT bool Started();
VTKM_CONT bool Stopped();
VTKM_CONT bool Ready();
VTKM_CONT vtkm::Float64 GetElapsedTime();
private:
@ -59,8 +69,10 @@ private:
void operator=(const DeviceAdapterTimerImplementation<vtkm::cont::DeviceAdapterTagCuda>&) =
delete;
bool StartReady;
bool StopReady;
cudaEvent_t StartEvent;
cudaEvent_t EndEvent;
cudaEvent_t StopEvent;
};
}
} // namespace vtkm::cont

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

@ -23,4 +23,4 @@ set(headers
Testing.h
)
vtkm_declare_headers(CUDA ${headers})
vtkm_declare_headers(${headers})

2
vtkm/cont/cuda/testing/UnitTestCudaMath.cu
View File

@ -48,7 +48,7 @@ struct TriggerICE : public vtkm::worklet::WorkletMapField
using ControlSignature = void(FieldIn, FieldIn, FieldOut);
using ExecutionSignature = _3(_1, _2, WorkIndex);
#if __CUDA_ARCH__
#ifdef VTKM_CUDA_DEVICE_PASS
template <class ValueType>
__device__ ValueType operator()(const ValueType& bad,
const ValueType& sane,

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