Previously an installed version of VTK-m wasn't relocatable as
it had system MPI paths. Additionally the installed vtkm_diy target
would depend on MPI but not `find_package(MPI)`
3c85f7f40 Correct undefined behavior from missing export on ErrorMessageBuffer
e298e05bc Test will now fail if programs such as UBSAN output "runtime error"
feb66f970 Make VTK-m use consistent symbol visibility for benchmarks
b43d61533 Make VTK-m use consistent symbol visibility for tests.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1699
It is very easy to cause ODR violations with DeviceAdapterTagCuda.
If you include that header from a C++ file and a CUDA file inside
the same program we an ODR violation. The reasons is that the C++
versions will say the tag is invalid, and the CUDA will say the
tag is valid.
The solution to this is that any compilation unit that includes
DeviceAdapterTagCuda from a version of VTK-m that has CUDA enabled
must be invoked by the cuda compiler.
When you install pyexpander with pip under python 3, the executable
script is now named expander3.py instead of expander.py. Support using
either file.
We now have a couple of the examples also being built against
the installed version of VTK-m as a test. This allow us to verify
that VTK-m installs and can be found properly.
0581b368f Fix issues with importing installed vtkm::cuda after refactor.
ed4374b05 diy 2019-03-13 (e8e68c7c)
b85dcf229 Add more vtkm_cont compilation units to device_sources.
9014de0eb Suppress new host/device warnings for cuda 10.1.
04a464cc4 Update cuda detection to create vtkm::cuda as an interface library.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !1582
Previously we didn't realize that the cmake_install.cmake files
would properly walk the entire install tree. Therefore we would try
to find each one manually and invoke it. This caused problems with
dirty continuous build directories, and was actually unneeded as
just including the root cmake_install.cmake is sufficient.
In certain circumstances (currently, when logging is enabled), VTK-m
libraries depend on the threading library. However, when the VTK-m
package was included from an external project, it did not automatically
find the threads package. This change makes the Threads library loaded
when the VTK-m package is found.
The purpose of the TestBuild infrastructure was to confirm that
VTK-m didn't have any lexical issues when it was a pure header
only project. As we now move to have more compiled components
the need for this form of testing is mitigated. Combined
with the issue of TestBuilds causing MSVC issues, we should
just remove this infrastructure.
Also
- Renamed vtkm::cont::make_DeviceAdapterIdFromName to just overload
make_DeviceAdapterId.
- Refactored CMake logic for unit tests
- Since we're now querying the device tracker for the names, they
cannot be all caps.
- Updated usages of InitLogging to use Initialize instead.
- Added changelog.
VTK-m has been updated to replace old per device worklet testing executables with a device
dependent shared library so that it's able to accept a device adapter
at runtime.
Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run
function would call ForceDevice when needed and if users need the device
adapter info at runtime, RunOnDevice function would pass the adapter into the functor.
Optional Parser is bumped from 1.3 to 1.7.
The FindTBB modules that come with packages such as OSPRay don't
provide TBB_LIBRARY_RELEASE but instead only provide TBB_LIBRARY.
If TBB_LIBRARY_RELEASE isn't found, and TBB_LIBRARY is we will use
that as the release library
Fixes issue #276.
OpenMP tests when run in parallel exhibit negative scaling as we
have N openMP processes each spawning N threads. We speculate that
this causes excessive context switching and swapping and reduces
performance.
9861cdecb Use CMake to automatically set policies to NEW.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Allison Vacanti <allison.vacanti@kitware.com>
Merge-request: !1270
CMake 3.12 introduces a ...<max> syntax in the version given to
cmake_minimum_required to automatically set policies to NEW up
to that version. Use it to avoid listing policies explicitly.
bef1965cd VTK-m now handles when TBB uses link scripts.
b2682ec5f VTK-m properly specifies the linker language of imported targets
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Brad King <brad.king@kitware.com>
Merge-request: !1264
If somebody is using the official TBB binaries on linux
they will encounter issues as the .so files are actually
link scripts which CMake doesn't support. We now manually
work around this problem.
Found via `codespell` and `grep`
more typos
includes source typo change and a typo that needs further review
follow-up typos
Follow-up typos
Revert a commit
The goal is to provide a way to disable VTK-m warning flags when used as a
thirdparty library.
VTK-m's stricter warning flags were cauing several new warnings in VTK.
80789a85 Export vtkm::cuda and vtkm::tbb targets as GLOBAL
3be5ee8a Fix usage of vtkm_compile_as_cuda in examples
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !1183
Previously vtkm_find_gl was only usable when rendering was enabled.
This is problematic as examples would use vtkm_find_gl even if
they didn't use vtkm rendering library.
d393468e Add any OpenGL link targets to test builds
8b9c0f50 Re-add non testable files to test build sources
ffd98463 Load correct file extension in header test build
7c5f44a6 Fix warnings about no symbols
289a4bc1 Differentiate between header files with different extensions
9571c9b5 Fix vtkm_add_header_build_test
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !1160
The code had 2 issues:
1. used obsolete 'output' if Git executable was missing. There was a
possibility that output variable was never set and used some garbage
value from parent scope.
2. version pattern matching was too liberal and would match
absolute any long txt so long as it has some numbers in it that matched
a typical version number.
Previously when an external project loaded VTK-m with find_package(VTKm)
and then tried to use anything with OpenGL, you would get compiler (and
probably linker) errors. The problem was that
VTKmRenderingContexts.cmake skipped over the loading of OpenGL libraries
because the vtkm_rendering_gl_context target was imported before this
code was ever called. Correct the problem by going through the motions
of checking OpenGL every time.
The vtkm_add_header_build_test was changed to identify "valid" header
files that were actually tested and only adding those to the source
list. This was a mistake. A big part of the point of adding headers that
are not tested to the test build sources is to list them to an IDE.
The test build file did not actually define any symbols, so the linker
might give a warning about it not being used in the library. Define some
unique symbol so that the linker will not complain.
If you tried to create test builds of a header.h and header.hxx, you
would get an error about building two files with the same name (tried to
build header.cxx for both of them). Fixed this by adding the original
extension name to the source file name.
The CMake configuration stopped creating any of the test builds. There
were a couple of errors introduced into this function that needed to be
fixed.
First, the condition on whether the testing should be skipped got
reversed. It was trying to create test build files for all the headers
that were not supposed to be built instead of the ones that were.
Second, the list of source files to build was not created correctly. The
set command that stored the name of the source file got removed, and so
nothing was being added to the list. I restored the variable and used
that consistently for the source file name.
73c05c10 Suppressions of __host__ warnings shouldn't trigger internal compile errors
5100e559 Suppress warnings about calling __host__ functions from CUDA 9.0
282c515e Suppress warnings about calling __host__ functions from CUDA 8.0
5dfdc830 Cuda will also print error/warning pragma values now.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !1150
3211c150 add support to run test with MPI.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Kenneth Moreland <kmorel@sandia.gov>
Merge-request: !1148
faf916f1 Fix condition on which to get the TBB version
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !1140
`vtkm_unit_tests` now supports an MPI option that can be used to add
test that run with MPI. Adding `UnitTestFieldRangeGlobalCompute` to test
global ranges for fields.
a37a3f39 Examples that use glu functions now properly link to OpenGL::GLU
a44ad273 Make sure Rendering example doesn't conflict with rendering testing name
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Utkarsh Ayachit <utkarsh.ayachit@kitware.com>
Merge-request: !1147
CUDA currently doesn't support building for `compute_` and having compiled
in virtuals ( using separable compilation ). So we need to transition everything
over to `sm_`
The FindTBB.cmake module gets the TBB version by reading and grepping
one of the header files. Before doing so, it checks to see if the
version variable already exists. The problem was it was checking
TBB_VERSION, which was never created. Worse, other build systems might
set this for us (for example, the ParaView superbuild). Correct this by
making sure both TBB_VERSION_MAJOR and TBB_VERSION_MINOR are set.
Previously there was a special build for the template source files
(.hxx) that installed them but did not create the test builds (because
they cannot be built outside of their enclosing .h file). It also added
an entry into the IDE that let them show up on the file list. However,
because they were not explicitly built as part of something actually
compiled, they did not have an compile options associated with them.
This caused confusion in some IDEs where it could not find the header
files it included, which made it more frustrating to edit them.
Due to limitations in the CUDA MSBuild support and how CMake stores the language
of a source file, we had to change VTK-m over to using generated .cu files
to signal when we want CUDA compilation.
The location of VTKmCheckPyexpander.cmake was originally set to $
{CMAKE_SOURCE_DIR}/CMake. This is correct with respect to the VTK-m
install, but incorrect if VTK-m is being included as a module in another
project (like VTK). Change the location to ${VTKm_CMAKE_MODULE_PATH},
which should be correct in every case.
A ParaView user noted that the determine version script (which is
essentially the same for ParaView and VTK-m) incorrectly used the
results of git describe when the source actually came from a tarball
distribution that was placed in another git archive. (The SHA was
incorrectly taken from the enclosing git project.) See the ParaView bug
for more details on the report:
https://gitlab.kitware.com/paraview/paraview/issues/17761
This fix simply checks to make sure the the source directory has the
.git subdirectory expected in all git projects.
There are still some warnings left:
* Some text in markdown files are incorrectly picked up as
doxygen commands
* ArrayPortalTransform weirdly inherits from a specialized
version of itself. It's technically correct C++ code, but
gives doxygen fits.
Sandia National Laboratories recently changed management from the
Sandia Corporation to the National Technology & Engineering Solutions
of Sandia, LLC (NTESS). The copyright statements need to be updated
accordingly.
When used as a submodule, redefining LIBRARY_OUTPUT_PATH and
EXECUTABLE_OUTPUT_PATH fails since the CMake default variables from the
containing project already exist.
CMake has several default build types, but if nothing is specified when
configuring your project it defaults to an empty string and no optimization
flags are used.
It will now default to using a debug build if the source directory is a git
clone, or a release build if not. Additionally when using ccmake or cmake-gui
this will provide a nice list of possible options for CMAKE_BUILD_TYPE.
when adding target_include_directories for the rendering library. I believe this happens because cmake determines that the variable VTKm_OPENGL_INCLUDE_DIRECTORIES is dependent on OPENGL_INCLUDE_DIRS( which is NOTFOUND). This causes cmake to raise an error even when VTKm_OPENGL_INCLUDE_DIRECTORIES is set to "".
In the FindTBB module, add the directory of the TBB includes and the
directory of the base tbb library to the list of paths to search for
TBB includes and libs, respectively. The reason is that TBB has its
initial includes and libraries and then has its support libraries.
Rather than enter entire paths 9 separate times, this allows you to
select the include directory once and one TBB library and the rest will
be automatically populated.
The vtkm_library macro was making all VTK-m libraries depend on all
other VTK-m libraries previously defined. This potentially creates
unnecessary linking. Instead, only depend on the backend libraries (like
TBB) and libraries explicitly given.
Most uses of ArrayRangeCompute just want to get the range of the data
and probably don't have a particular device in mind. Thus, it is better
to use a TryExecute internally use whatever devices are available.
Note that when using TryExecute, the calling code is expected to be able
to support all devices. That might not always be the case. Thus, I am
experimenting a bit with how we incorporate this in a library. The
advantage of having the code compiled in a library is that you only have
to compile it once and the calling code does not need to worry about
CUDA, etc.
However, because ArrayRangeCompute is templated, we can only pre-compile
some subset of array handle types. The most common are compiled into the
code (matching all the predefined ArrayHandles as well as some special
cases). If the code wants to use some other type, it has to include
ArrayRangeCompute.hxx. The only place where this is necessary is a test
that intentially trys to find the range on an uncommon type.
If array portals were to support virtual methods, then we should be able
to modify this code so that we could precompile for all array handle
types.
The RuntimeDeviceTracker.cxx contains a library method that queries the
CUDA device, which only works if compiled as a CUDA source file.
This set up will allow code that is not compiled with CUDA use a
RuntimeDeviceTracker with other code that does use CUDA.
fc68362d Build benchmarks even when testing is not enabled.
31e20859 Fix typo.
Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Robert Maynard <robert.maynard@kitware.com>
Merge-request: !696
Previously if you constructed an array handle without allocating it, you
would get an error if you tried to use the array as input. This
conflicted with some recent changes to accept empty vectors.
Now when you try to use an unallocated ArrayHandle as input (calling
PrepareForInput or PrepareForInPlace), it internally calls Allocate(0)
(to establish internal state) and sets up a valid execution ArrayPortal
of size 0.
Class that need to be passed across dynamic library boundaries such as
DynamicArrayHandle need to be properly export. One of 'tricks' of this
is that templated classes such as PolymorphicArrayHandleContainer need
the Type and Storage types to have public visibility.
This makes sure that all vtkm storage tags have public visibility so
in the future we can transfer dynamic array handles across libraries.
During a round of resolving compile issues on the dashboard, the test
builds were disabled, but never re-enabled. This change re-enables the
test builds.
Change the OpenGL configuration to require GLEW as most of the OpenGL
code actually requires GLEW (or will as soon as the VBO branch gets
merged in).
Also removed some stray find_package commands and rearranged the
configuration to use the vtkm_configure_component_* commands instead.
Recently VTK-m was changed to require C++11. The internal builds set
properties to require C++11, but these never make it to the
configuration for projects that use the VTK-m package (i.e. not declared
in VTKmConfig.cmake).
This change adds a new CMake target, vtkm, which is an interface. It
does not point to an actual library, but it allows code that links it in
to have the appropriate compile flags.
