Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
39934257cb
vtk-m/vtkm/cont/CMakeLists.txt

325 lines
8.5 KiB
CMake
Raw Normal View History

Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
##============================================================================
## Copyright (c) Kitware, Inc.
## All rights reserved.
## See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
##
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
## 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.
##============================================================================
set(headers
adding a wrapper for device adapter algorithm
2017-11-29 15:44:37 +00:00
Algorithm.h
Create ArrayCopy method This is a convenience method to do a deep copy of an array. This comes up a lot, but can be a pain if you don't have a specific device adapter on which to do the copy.
2017-09-25 22:28:44 +00:00
ArrayCopy.h
Add ArrayExtractComponent function `ArrayExtractComponent` allows you to get a component of an array. Unlike `ArrayHandleExtractComponent`, the type you get is always the same: an `ArrayHandleStride`. This way, you can get an array that contains the data of an extracted component with less templating and potentially dramatically reduce the amount of code generated (although some runtime integer arithmetic is added).
2020-09-10 23:54:12 +00:00
ArrayExtractComponent.h
Add ArrayGetValue[s] to address issue #355.
2019-08-20 21:28:19 +00:00
ArrayGetValues.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
ArrayHandle.h
Replace basic ArrayHandle implementation to use Buffers This encapsulates a lot of the required memory management into the Buffer object and related code. Many now unneeded classes were deleted.
2020-04-22 19:58:59 +00:00
ArrayHandleBasic.h
Add ArrayHandleBitField, a boolean-valued AH backed by a BitField.
2019-03-07 21:45:21 +00:00
ArrayHandleBitField.h
Fix compile issues. Add new files to CMakeLists.txt
2015-12-22 17:41:30 +00:00
ArrayHandleCartesianProduct.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
ArrayHandleCast.h
Created ArrayHandleCompositeVector. This derived array handle creates an array of vectors whose components come from other arrays of vectors. In either case ArrayHandleCompositeVector handles scalars as vectors of size 1.
2014-05-05 15:24:03 +00:00
ArrayHandleCompositeVector.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
ArrayHandleConcatenate.h
Add ArrayHandleConstant
2015-05-13 20:24:51 +00:00
ArrayHandleConstant.h
Add a dynamic array handle. The dynamic array handle holds a reference to an array handle of an unknown type. It contains the ability to try to cast it to an instance of array handle or to try lists of types and containers. There is currently an issue that is causing the test code not to compile. It is the case that some combinations of types and containers are not compatible. For example, an implict container is bound to a certain type, and the container is undefined if they do not agree. There needs to be a mechanism to detect these invalid combinations and skip over them in the MTP for each.
2014-04-03 19:17:14 +00:00
ArrayHandleCounting.h
Add ArrayPortalDecorator.
2019-09-06 22:24:27 +00:00
ArrayHandleDecorator.h
Add ArrayHandleDiscard for unused outputs. ArrayHandleDiscard is intended to be used for worklets that produce multiple output arrays when one or more outputs is not needed. It does not allocate space for its data and the Set method is a no-op, allowing the compiler to prune unnecessary instructions. Reading from the array handle is not allowed.
2017-02-07 17:53:53 +00:00
ArrayHandleDiscard.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
ArrayHandleExtractComponent.h
Add ArrayHandleGroupVec This is a fancy array handle that groups consecutive entries in a delegate array handle and presents them as a single vec.
2015-09-28 23:19:38 +00:00
ArrayHandleGroupVec.h
Implement ArrayHandleGroupVecVariable This is a fancy array handle that can group entries in another array by arbitrary amounts. This allows us to implement input and output arrays with a different sized Vec for each instance. This is necessary for generating new topologies with cells of different types.
2016-10-28 03:14:29 +00:00
ArrayHandleGroupVecVariable.h
Add ArrayHandleImplicit.
2015-02-13 06:24:43 +00:00
ArrayHandleImplicit.h
Add ArrayHandleIndex class. This is the most common use case for ArrayHandleCounting, and this class is a bit easier to use and a bit faster.
2015-09-15 04:11:09 +00:00
ArrayHandleIndex.h
Create ArrayHandleMultiplexer
2019-07-15 04:51:28 +00:00
ArrayHandleMultiplexer.h
Create ArrayHandleOffsetsToNumComponents This is a fancy array that takes an array of offsets and converts it to an array of the number of components for each packed entry. This replaces the use of `ArrayHandleDecorator` in `CellSetExplicit`. The two implementation should do the same thing, but the new `ArrayHandleOffsetsToNumComponents` should be less complex for compilers.
2020-09-24 18:16:11 +00:00
ArrayHandleOffsetsToNumComponents.h
Add ArrayHandlePermutation Also found a problem with ArrayHandle that manifests itself with derived types when you first do a PrepareForInput and then a PrepareForInPlace. The ArrayHandle assumes the data is already moved to the device and skips the in place call to the array transfer. However, this means the transfer of the derived array handle does not have a chance to set up for in place. I think the appropriate solution may be to move the appropriate logic from ArrayHandle to ArrayTransfer. I will look into that next.
2015-04-24 00:45:24 +00:00
ArrayHandlePermutation.h
Add ArrayHandleRecombineVec The primary purpose of `ArrayHandleRecombineVec` is to take arrays returned from `ArrayExtractComponent` and recombine them again into a single `ArrayHandle` that has `Vec` values.
2020-12-23 15:48:13 +00:00
ArrayHandleRecombineVec.h
add ArrayHandleReverse.h in CMakeLists.txt
2017-05-08 17:49:18 +00:00
ArrayHandleReverse.h
Add ArrayHandleRandomStandardNormal
2020-06-17 21:48:09 +00:00
ArrayHandleRandomStandardNormal.h
Incorporating Ken's commnet Rename class, directory and namespace names, remove convinience function.
2020-03-18 22:03:47 +00:00
ArrayHandleRandomUniformBits.h
ArrayHandleRandomUniformReal Add an ArrayHandle for generating random Float64 in the range of [0, 1).
2020-06-02 17:58:57 +00:00
ArrayHandleRandomUniformReal.h
Add ArrayHandleSOA This ArrayHandle should behave just like the one with basic storage but external arrays stored by component can be shallow-copied to them.
2019-08-06 00:15:21 +00:00
ArrayHandleSOA.h
Add ArrayHandleStride
2020-09-09 20:17:59 +00:00
ArrayHandleStride.h
Add ArrayHandleSwizzle for reordering/removing components from a vec array. This is tangentially related to #43.
2017-07-28 18:55:37 +00:00
ArrayHandleSwizzle.h
Add ArrayHandleTransform.
2015-04-13 20:43:18 +00:00
ArrayHandleTransform.h
Add implicit array for uniform grid point coordinates.
2014-05-01 23:19:54 +00:00
ArrayHandleUniformPointCoordinates.h
Add ArrayHandleView Adds a fancy array handle that restricts access to an array to some window of values. It takes a start offset and a size and represents the values between that start offset and size past that.
2018-08-29 20:54:31 +00:00
ArrayHandleView.h
update XGC ArrayHandles to new buffer style
2020-12-15 18:59:19 +00:00
ArrayHandleXGCCoordinates.h
Add ArrayHandleZip. Allows both reading and writing to a vtkm::pair of values.
2015-04-23 17:20:03 +00:00
ArrayHandleZip.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
ArrayPortal.h
Add ArrayPortalToIterators functionality. This moves the ability to get an iterator from an array portal out of the portal itself. The next step is to move the GetIteratorBegin/End out of ArrayPortal. This should make the implemenation a bit cleaner.
2014-09-04 17:56:15 +00:00
ArrayPortalToIterators.h
Move ComputeRange for ArrayHandle to its own header It will be convenient to make this accessible outside of Field.
2016-08-05 20:05:32 +00:00
ArrayRangeCompute.h
Deprecate templated versions of Field::GetRange Instead, always use precompiled versions of range computing. This means you won't be able to specify the type. Currently, types are limited to scalars vecs up to size 4. The main motivation for this change is to allow you to include Field.h with a non-device compiler. This is an important feature for our customers. I plan in the future to implement a mechanism to pull out a component of most ArrayHandle's as a single array. This would enable us to support a precompiled version that can compute the range of arbitrarily sized Vecs.
2020-10-20 19:22:43 +00:00
ArrayRangeComputeTemplate.h
`MultiBlock` renamed to `PartitionedDataSet` The `MultiBlock` class has been renamed to `PartitionedDataSet`, and its API has been refactored to refer to "partitions", rather than "blocks". Additionally, the `AddBlocks` method has been changed to `AppendPartitions` to more accurately reflect the operation performed. The associated `AssignerMultiBlock` class has also been renamed to `AssignerPartitionedDataSet`. This change is motivated towards unifying VTK-m's data model with VTK. VTK has started to move away from `vtkMultiBlockDataSet`, which is a hierarchical tree of nested datasets, to `vtkPartitionedDataSet`, which is always a flat vector of datasets used to assist geometry distribution in multi-process environments. This simplifies traversal during processing and clarifies the intent of the container: The component datasets are partitions for distribution, not organizational groupings (e.g. materials). Ref #405
2019-09-02 14:38:47 +00:00
AssignerPartitionedDataSet.h
Change the namespacing of atomic array moved the execution object to vtkm::exec and AtomicArray to vtkm::cont
2018-06-07 21:08:02 +00:00
AtomicArray.h
Add support for BitFields. BitFields are: - Stored in memory using a contiguous buffer of bits. - Accessible via portals, a la ArrayHandle. - Portals operate on individual bits or words. - Operations may be atomic for safe use from concurrent kernels. The new BitFieldToUnorderedSet device algorithm produces an ArrayHandle containing the indices of all set bits, in no particular order. The new AtomicInterface classes provide an abstraction into bitwise atomic operations across control and execution environments and are used to implement the BitPortals.
2019-03-05 21:47:09 +00:00
BitField.h
Add `BoundsCompute` and `BoundsGlobalCompute` Adding compute function to compute local and global bounds for datasets and multiblocks alike.
2018-04-05 21:12:20 +00:00
BoundsCompute.h
BoundsGlobalCompute.h
Move vtkm::cont::CastAndCall into a header in vtkm/cont Since CastAndCall is meant to be a user callable function, we should make sure it is part of the vtkm cont headers
2019-04-03 18:15:26 +00:00
CastAndCall.h
Add CellLocator to name of BoundingIntervalHierarchy This will help identify the nature of this object as well as find cell locator implementations.
2018-07-12 21:34:29 +00:00
CellLocatorBoundingIntervalHierarchy.h
Add CellLocatorChooser `CellLocatorChooser` allows you to select a cell locator at compile time. Unlike `CellLocatorGeneral`, you have to deduce what cell set types you might have, but you don't have to have a large switch statement in the middle of your worklet.
2020-11-11 21:14:31 +00:00
CellLocatorChooser.h
Add CellLocatorGeneral A general purpose `CellLocator` that should work with any type of dataset. Internally, it tries to chose one of the existing cell locators that would be optimal for the input data. Also removes `CellLocatorHelper`.
2019-03-29 17:28:27 +00:00
CellLocatorGeneral.h
Updates to the Cell Locators - Adding updates to uniform grid cell locator - adding OpenMP test, updating copyrights - Adding rectilinear grid cell locator - adding unit tests for serial, tbb, OpenMP, and cuda - Updating CMakeLists to honor the alphabetical ordering
2019-01-07 01:18:23 +00:00
CellLocatorRectilinearGrid.h
Rename CellLocatorUniformBins to CellLocatorTwoLevel The new name is more descriptive and prevents confusion with CellLocatorUniformGrid.
2020-09-21 21:35:30 +00:00
CellLocatorTwoLevel.h
Rename CellLocatorTwoLevelUniformGrid to CellLocatorUniformBins Also make it a concrete sub-class of vtkm::cont::CellLocator Fixes issue #251
2019-03-28 14:00:32 +00:00
CellLocatorUniformBins.h
Fixing Point Locator interface. - Fixing the point locator interface to make it consistent with the CellLocator interface
2018-08-29 21:19:31 +00:00
CellLocatorUniformGrid.h
Include all the new DataSet header in CMakeLists. This will make sure that we properly install these headers.
2015-05-29 14:49:57 +00:00
CellSet.h
CellSetExplicit.h
First Extrude commit. how did any of this work? match other CellSet file layouts. ??? compile in CUDA. unit tests. also only serial. make error message accurate Well, this compiles and works now. Did it ever? use CellShapeTagGeneric UnitTest matches previous changes. whoops Fix linking problems. Need the same interface as other ThreadIndices. add filter test okay, let's try duplicating CellSetStructure. okay inching... change to wedge in CellSetListTag Means changing these to support it. switch back to wedge from generic compiles and runs remove ExtrudedType need vtkm_worklet vtkm_worklet needs to be included fix segment count for wedge specialization need to actually save the index for the other constructor. specialize on Explicit clean up warning angled brackets not quotes. formatting
2019-06-06 18:43:53 +00:00
CellSetExtrude.h
Convert uses of ListTagBase to List
2019-12-05 21:38:41 +00:00
CellSetList.h
Created DynamicCellSet The DynamicCellSet will be used in place of the pointer to a CellSet in a DataSet. This will prevent us from having to cast it all the time and also remove reliance on boost smart_ptr.
2015-07-27 16:13:27 +00:00
CellSetListTag.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
CellSetPermutation.h
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
CellSetSingleType.h
Include all the new DataSet header in CMakeLists. This will make sure that we properly install these headers.
2015-05-29 14:49:57 +00:00
CellSetStructured.h
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
ColorTable.h
Move ColorTable mapping to its own header We would really like to be able to include `vtkm::cont::ColorTable` in such a way that you don't have to compile device code (unless you are actually compiling functions for the device). Thus, the `Map` functions of `ColorTable` were in a special `ColorTable.hxx` that contains the "implementation" for `ColorTable`. That is confusing to many users. It is more clear to simply have `.h` headers that do a specific thing. To achieve these two goals, the `Map` functionality of `ColorTable` is separated out into its own header file. So you don't need to be using a device compiler just to use `ColorTable` (including `ColorTable.h`), but you do need to use a device compiler if mapping values to colors (including `ColorTableMap.h`).
2020-09-14 22:39:51 +00:00
ColorTableMap.h
Introduce vtkm::cont::ColorTable replacing vtkm::rendering::ColorTable The new and improved vtkm::cont::ColorTable provides a more feature complete color table implementation that is modeled after vtkDiscretizableColorTransferFunction. This class therefore supports different color spaces ( rgb, lab, hsv, diverging ) and supports execution across all device adapters.
2018-01-18 18:55:15 +00:00
ColorTableSamples.h
Consolidate count-to-offset algorithms For no particularly good reason, there were two functions that converted and array of counts to an array of offsets: `ConvertNumComponentsToOffsets` and `ConvertNumIndicesToOffsets`. These functions were identical, except one was defined in `ArrayHandleGroupVecVariable.h` and the other was defined in `CellSetExplicit.h`. These two functions have been consolidated into one (which is now called `ConvertNumComponentsToOffsets`). The consolidated function has also been put in its own header file: `ConvertNumComponentsToOffsets.h`. Normally, backward compatibility would be established using deprecated features. However, one of the things being worked on is the removal of device-specific code (e.g. `vtkm::cont::Algorithm`) from core classes like `CellSetExplicit` so that less code needs to use the device compiler (especially downstream code). Part of this change removed unnecessary includes of `Algorithm.h` in `ArrayHandleGroupVecVariable.h` and `CellSetExplicit.h`. This header had to be added to some classes that were not including it themselves.
2021-08-18 20:47:40 +00:00
ConvertNumComponentsToOffsets.h
Include all the new DataSet header in CMakeLists. This will make sure that we properly install these headers.
2015-05-29 14:49:57 +00:00
CoordinateSystem.h
Merge branch 'datamodel-design' of public.kitware.com:vtkm into datamodel-design Conflicts: CMakeLists.txt
2015-01-27 22:02:03 +00:00
DataSet.h
Add helper class to build curvilinear datasets.
2021-06-09 17:50:01 +00:00
DataSetBuilderCurvilinear.h
Fix compile issues. Add new files to CMakeLists.txt
2015-12-22 17:41:30 +00:00
DataSetBuilderExplicit.h
DataSetBuilderRectilinear.h
Change Regular to Uniform There was an inconsistency in naming classes where axes-aligned grids with even spacing were sometimes called "uniform" and sometimes called "regular". Maintain consistency by always calling them uniform.
2016-01-19 22:54:05 +00:00
DataSetBuilderUniform.h
Fix compile issues. Add new files to CMakeLists.txt
2015-12-22 17:41:30 +00:00
DataSetFieldAdd.h
Add in a serial device adapter and required supporting classes. We now can verify that the array handle is usable by a device adapter.
2014-02-11 17:34:56 +00:00
DeviceAdapter.h
move DeviceAdapterAlgorithm to correct folder as it's namespace
2014-11-25 14:14:04 +00:00
DeviceAdapterAlgorithm.h
Convert uses of ListTagBase to List
2019-12-05 21:38:41 +00:00
DeviceAdapterList.h
Add general ability to try execution on multiple devices There are various reasons why you might want to execute something but not have a specific device to execute on. To mange this, add a general function that will try a list of devices in order and attempt to run on them in order.
2016-08-15 23:15:17 +00:00
DeviceAdapterListTag.h
Move DeviceAdapterTag to vtkm/cont
2019-04-03 20:28:31 +00:00
DeviceAdapterTag.h
Created DynamicCellSet The DynamicCellSet will be used in place of the pointer to a CellSet in a DataSet. This will prevent us from having to cast it all the time and also remove reliance on boost smart_ptr.
2015-07-27 16:13:27 +00:00
DynamicCellSet.h
Add `EnvironmentTracker` to track MPI communicator. When using MPI, we need a mechanism in VTK-m to set/get the MPI controller. Added `EnvironmentTracker` to do that.
2017-12-14 01:30:04 +00:00
EnvironmentTracker.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
Error.h
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
ErrorBadAllocation.h
Add ErrorBadDevice
2017-12-22 15:01:09 +00:00
ErrorBadDevice.h
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
ErrorBadType.h
ErrorBadValue.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
ErrorExecution.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
ErrorFilterExecution.h
Simplify exception hierarchy. Remove the ErrorControl class such that all subclasses now inherit from error. Renamed all exception classes via s/ErrorControl/Error/. See issue #57.
2017-01-09 21:15:32 +00:00
ErrorInternal.h
Add ExecutionAndControlObjectBase This is a subclass of ExecutionObject and a superset of its functionality. In addition to having a PrepareForExecution method, it also has a PrepareForControl method that gets an object appropriate for the control environment. This is helpful for situations where you need code to work in both environments, such as the functor in an ArrayHandleTransform. Also added several runtime checks for execution objects and execution and cotnrol objects.
2018-09-08 17:07:06 +00:00
ExecutionAndControlObjectBase.h
Replace ExecutionObjectFactoryBase with ExecutionObjectBase While making changes to how execution objects work, we had agreed to name the base object ExecutionObjectBase instead of its original name of ExecutionObjectFactoryBase. Somehow that change did not make it through.
2018-05-10 23:53:39 +00:00
ExecutionObjectBase.h
Include all the new DataSet header in CMakeLists. This will make sure that we properly install these headers.
2015-05-29 14:49:57 +00:00
Field.h
add FieldRangeCompute.
2018-04-05 01:13:44 +00:00
FieldRangeCompute.h
FieldRangeGlobalCompute.h
Switch from faux to true virtuals
2017-10-23 13:38:33 +00:00
ImplicitFunctionHandle.h
Add vtkm::cont::Initialize. 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.
2018-12-06 18:33:31 +00:00
Initialize.h
Move Invoker into vtkm/cont The Invoker is a control side object that handles the construction of the relevant worklet dispatcher. Moving it to control makes it obvious that it isn't an algorithm itself but a way to launch worklets.
2019-07-31 17:50:23 +00:00
Invoker.h
Initial implementation of general logging. Addresses #291.
2018-08-30 17:29:36 +00:00
Logging.h
Create a function for copying fields from particle arrays.
2020-06-18 18:54:18 +00:00
ParticleArrayCopy.h
`MultiBlock` renamed to `PartitionedDataSet` The `MultiBlock` class has been renamed to `PartitionedDataSet`, and its API has been refactored to refer to "partitions", rather than "blocks". Additionally, the `AddBlocks` method has been changed to `AppendPartitions` to more accurately reflect the operation performed. The associated `AssignerMultiBlock` class has also been renamed to `AssignerPartitionedDataSet`. This change is motivated towards unifying VTK-m's data model with VTK. VTK has started to move away from `vtkMultiBlockDataSet`, which is a hierarchical tree of nested datasets, to `vtkPartitionedDataSet`, which is always a flat vector of datasets used to assist geometry distribution in multi-process environments. This simplifies traversal during processing and clarifies the intent of the container: The component datasets are partitions for distribution, not organizational groupings (e.g. materials). Ref #405
2019-09-02 14:38:47 +00:00
PartitionedDataSet.h
PointLocatorUniformGrid Provide an accelerated neareast neighbor search of points in the dataset using a one layer uniform grid.
2017-10-19 17:44:36 +00:00
PointLocatorUniformGrid.h
Rename PointLocatorUniformGrid to PointLocatorSparseGrid The new name reflects better what the underlying algorithm does. It also helps prevent confusion about what types of data the locator is good for. The old name suggested it only worked for structured grids, which is not the case.
2020-09-21 20:49:03 +00:00
PointLocatorSparseGrid.h
Install RuntimeDeviceInformation.h.
2015-12-23 19:54:41 +00:00
RuntimeDeviceInformation.h
Move RuntimeDeviceTracker to vtkm::cont Before it was in the vtkm::cont::internal namespace. However, we expect to be using this feature quite a bit more as we want VTK-m to handle multiple devices effectively (as in, just figure it out and go).
2017-02-22 20:33:52 +00:00
RuntimeDeviceTracker.h
Add ArrayHandle Serialization
2018-06-08 15:56:40 +00:00
Serialization.h
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
Storage.h
Re-introduced deprecated StorageImplicit.h The `StorageImplicit.h` header is no longer used. However, just removing it causes compiles to fail if they include it. To make the transition better, re-add this file, but cause a deprecation warning if it is included.
2020-11-20 00:31:55 +00:00
StorageImplicit.h # Deprecated, rolled into ArrayHandleImplicit.h
Convert uses of ListTagBase to List
2019-12-05 21:38:41 +00:00
StorageList.h
Change ArrayContainerControl to Storage. After a talk with Robert Maynard, we decided to change the name ArrayContainerControl to Storage. There are several reasons for this change. 1. The name ArrayContainerControl is unwieldy. It is long, hard for humans to parse, and makes for long lines and wraparound. It is also hard to distinguish from other names like ArrayHandleFoo and ArrayExecutionManager. 2. The word container is getting overloaded. For example, there is a SimplePolymorphicContainer. Container is being used for an object that literally acts like a container for data. This class really manages data. 3. The data does not necessarily have to be on the control side. Implicit containers store the data nowhere. Derivative containers might have all the real data on the execution side. It is possible in the future to have storage on the execution environment instead of the control (think interfacing with a simulator on the GPU). Storage is not a perfect word (what does implicit storage really mean?), but its the best English word we came up with.
2014-06-23 23:33:04 +00:00
StorageListTag.h
Add Timer class. Helpful for safely timing parallel code across different devices.
2014-06-10 18:53:34 +00:00
Timer.h
Add Token
2020-01-15 04:47:11 +00:00
Token.h
Add general ability to try execution on multiple devices There are various reasons why you might want to execute something but not have a specific device to execute on. To mange this, add a general function that will try a list of devices in order and attempt to run on them in order.
2016-08-15 23:15:17 +00:00
TryExecute.h
Clarify intent of TypeString and TypeName functions. TypeName is used for logging, and is now TypeToString. TypeString is used for serialization, and is now SerializableTypeString.
2019-02-28 18:15:27 +00:00
SerializableTypeString.h
Add UncertainArrayHandle
2020-08-05 12:42:33 +00:00
UncertainArrayHandle.h
Add UnknownArrayHandle
2020-08-05 03:16:29 +00:00
UnknownArrayHandle.h
Rename ArrayHandleVariant to VariantArrayHandle.
2018-12-11 13:56:08 +00:00
VariantArrayHandle.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
)
A thought on what CMake 3.9 would mean to VTK-m.
2017-09-25 12:47:47 +00:00
set(template_sources
Reintroduce ArrayRangeCompute.hxx as deprecated ArrayRangeCompute.hxx was removed, but other code may be including it. The file was replaced. It now just includes its replacement (ArrayRangeComputeTemplate.h) and forces a deprecation warning.
2020-11-10 16:58:50 +00:00
ArrayRangeCompute.hxx # Deprecated, replaced with ArrayRangeComputeTemplate.h
Streamline CellSetExplicit 1) Don't require a DeviceAdapter for the BuildConnectivity function (#131) 2) Explicitly instantiate default CellSetExplicit and CellSetSingleType
2017-08-10 20:13:58 +00:00
CellSetExplicit.hxx
Generalize fields for particle advection
2020-07-21 01:15:46 +00:00
ParticleArrayCopy.hxx
Install missing headers found by VTKmCheckSourceInInstall
2019-01-29 19:28:19 +00:00
VirtualObjectHandle.hxx
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
)
set(sources
ArrayHandle.cxx
Replace basic ArrayHandle implementation to use Buffers This encapsulates a lot of the required memory management into the Buffer object and related code. Many now unneeded classes were deleted.
2020-04-22 19:58:59 +00:00
ArrayHandleBasic.cxx
Add ArrayHandleSOA This ArrayHandle should behave just like the one with basic storage but external arrays stored by component can be shallow-copied to them.
2019-08-06 00:15:21 +00:00
ArrayHandleSOA.cxx
Add ArrayHandleStride
2020-09-09 20:17:59 +00:00
ArrayHandleStride.cxx
Add ArrayExtractComponent function `ArrayExtractComponent` allows you to get a component of an array. Unlike `ArrayHandleExtractComponent`, the type you get is always the same: an `ArrayHandleStride`. This way, you can get an array that contains the data of an extracted component with less templating and potentially dramatically reduce the amount of code generated (although some runtime integer arithmetic is added).
2020-09-10 23:54:12 +00:00
ArrayHandleUniformPointCoordinates.cxx
Store the number of bits of a BitField in the Buffer's metadata The number of bits in a `BitField` cannot be directly implied from the size of the buffer (because the buffer gets padded to the nearest sized word). Thus, the `BitField stored the number of bits in its own internals. Unfortunately, that caused issues when passing the `BitField` data between it and an `ArrayHandleBitField`. If the `ArrayHandleBitField` resized itself, the `BitField` would not see the new size because it ignored the new buffer size. To get around this problem, `BitField` now declares its own `BufferMetaData` that stores the number of bits. Now, since the number of bits is stored in the `Buffer` object, it is sufficient to just share the `Buffer` to synchronize all of the state.
2020-08-24 21:26:57 +00:00
BitField.cxx
Update presets for ColorTable The ParaView project went through a rigourous selection process for a short list of color tables. Let's replicate that for our presets.
2018-10-30 17:42:10 +00:00
ColorTablePresets.cxx
For VTK-m libs all includes of DeviceAdapterTagCuda happen from cuda files 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.
2019-04-17 17:59:49 +00:00
DeviceAdapterTag.cxx
Add `EnvironmentTracker` to track MPI communicator. When using MPI, we need a mechanism in VTK-m to set/get the MPI controller. Added `EnvironmentTracker` to do that.
2017-12-14 01:30:04 +00:00
EnvironmentTracker.cxx
Replace FindDeviceAdapterTagAndCall with TryExecuteOnDevice Also add a throwFailedRuntimeDeviceTransfer that throws a nicely detailed message on why a something couldn't be transfered to the requested device adapter.
2018-08-08 18:53:28 +00:00
ErrorBadDevice.cxx
Add StorageVirtual and ArrayHandleVirtual to vtkm::cont
2018-11-06 16:20:30 +00:00
ErrorBadType.cxx
Add Buffer class The buffer class encapsulates the movement of raw C arrays between host and devices. The `Buffer` class itself is not associated with any device. Instead, `Buffer` is used in conjunction with a new templated class named `DeviceAdapterMemoryManager` that can allocate data on a given device and transfer data as necessary. `DeviceAdapterMemoryManager` will eventually replace the more complicated device adapter classes that manage data on a device. The code in `DeviceAdapterMemoryManager` is actually enclosed in virtual methods. This allows us to limit the number of classes that need to be compiled for a device. Rather, the implementation of `DeviceAdapterMemoryManager` is compiled once with whatever compiler is necessary, and then the `RuntimeDeviceInformation` is used to get the correct object instance.
2020-03-26 23:34:18 +00:00
internal/Buffer.cxx
internal/DeviceAdapterMemoryManager.cxx
internal/DeviceAdapterMemoryManagerShared.cxx
Implement RuntimeDeviceConfiguration
2021-05-26 19:43:36 +00:00
internal/RuntimeDeviceConfiguration.cxx
internal/RuntimeDeviceConfigurationOptions.cxx
internal/RuntimeDeviceOption.cxx
Add vtkm::cont::Initialize. 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.
2018-12-06 18:33:31 +00:00
Initialize.cxx
Initial implementation of general logging. Addresses #291.
2018-08-30 17:29:36 +00:00
Logging.cxx
vtkm_cont listed non-device sources as device-source Cleanup the device sources list in vtkm_cont to only contain .cxx files that could invoke cuda
2018-07-19 16:59:34 +00:00
RuntimeDeviceTracker.cxx
Add standard support for read-only storage Many of the fancy `ArrayHandle`s are read-only and therefore connot really create write portals. Likewise, many `ArrayHandle`s (both read- only and read/write) have no way to resize themselves. In this case, implementing the `CreateWritePortal` and `ResizeBuffers` methods in the `Storage` class was troublesome. Mostly they just threw an exception, but they also sometimes had to deal with cases where the behavior was allowed. To simplify code for developers, this introduces a pair of macros: `VTKM_STORAGE_NO_RESIZE` and `VTKM_STORAGE_NO_WRITE_PORTAL`. These can be declared in a `Storage` implementation when the storage has no viable way to resize itself and create a write portal, respectively. Having boilerplate code for these methods also helps work around expected behavior for `ResizeBuffers`. `ResizeBuffers` should silently work when resizing to the same size. Also `ResizeBuffers` should behave well when resizing to 0 as that is what `ReleaseResources` does.
2020-12-07 22:19:24 +00:00
Storage.cxx
Add Token
2020-01-15 04:47:11 +00:00
Token.cxx
vtkm_cont listed non-device sources as device-source Cleanup the device sources list in vtkm_cont to only contain .cxx files that could invoke cuda
2018-07-19 16:59:34 +00:00
TryExecute.cxx
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
)
Add general `ArrayCopy` between `UnknownArrayHandle`s Add an overload of `ArrayCopy` that takes `UnknownArrayHandle`s and copies them for (almost) any `ArrayHandle` type. The code uses `CastAndCallWithExtractedArray` to reduce the total number of copy conditions to about 100, which are all precompiled into the library. On a debug build on my mac, this creates a .o file of 21MB. That's not great, but not terrible. Hopefully, this can be used to consolidate copy implementations elsewhere.
2021-01-14 22:25:09 +00:00
# This list of sources has code that uses devices and so might need to be
# compiled with a device-specific compiler (like CUDA).
set(device_sources
ArrayCopy.cxx
Compile ArrayGetValues implementation in library Previously, all of the `ArrayGetValues` implementations were templated functions that had to be built. That meant that any code using them had to be compiled with a device compiler and create special code for it. This change uses an `UnknownArrayHandle` to encapsulate the `ArrayHandle` and call a per-compiled library function. This means that the code only has to be compiled once.
2021-08-05 21:58:34 +00:00
ArrayGetValues.cxx
Use ArrayRangeCompute without specifying a device 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.
2017-02-24 00:12:14 +00:00
ArrayRangeCompute.cxx
`MultiBlock` renamed to `PartitionedDataSet` The `MultiBlock` class has been renamed to `PartitionedDataSet`, and its API has been refactored to refer to "partitions", rather than "blocks". Additionally, the `AddBlocks` method has been changed to `AppendPartitions` to more accurately reflect the operation performed. The associated `AssignerMultiBlock` class has also been renamed to `AssignerPartitionedDataSet`. This change is motivated towards unifying VTK-m's data model with VTK. VTK has started to move away from `vtkMultiBlockDataSet`, which is a hierarchical tree of nested datasets, to `vtkPartitionedDataSet`, which is always a flat vector of datasets used to assist geometry distribution in multi-process environments. This simplifies traversal during processing and clarifies the intent of the container: The component datasets are partitions for distribution, not organizational groupings (e.g. materials). Ref #405
2019-09-02 14:38:47 +00:00
AssignerPartitionedDataSet.cxx
Add more vtkm_cont compilation units to device_sources. These depend on DeviceAdapterTagCuda::IsEnabled being correctly set at compile time.
2019-03-13 17:58:35 +00:00
BoundsCompute.cxx
BoundsGlobalCompute.cxx
Put CellLocatorBoundingIntervalHierarchy in vtkm_cont library All of the methods in CellLocatorBoundingIntervalHierarchy were listed in header files. This is sometimes problematic with virtual methods. Since everything implemented in it can just be embedded in a library, move the code into the vtkm_cont library.
2019-03-20 21:28:08 +00:00
CellLocatorBoundingIntervalHierarchy.cxx
Add CellLocatorGeneral A general purpose `CellLocator` that should work with any type of dataset. Internally, it tries to chose one of the existing cell locators that would be optimal for the input data. Also removes `CellLocatorHelper`.
2019-03-29 17:28:27 +00:00
CellLocatorGeneral.cxx
Move virtual methods of other CellLocators to vtkm_cont These changes caused some warnings in clang to show up based on virtual methods in other cell locators. Hence, the rest of the cell locators have also had some of their code moved to vtkm_cont.
2019-03-20 23:38:50 +00:00
CellLocatorRectilinearGrid.cxx
Rename CellLocatorUniformBins to CellLocatorTwoLevel The new name is more descriptive and prevents confusion with CellLocatorUniformGrid.
2020-09-21 21:35:30 +00:00
CellLocatorTwoLevel.cxx
Move virtual methods of other CellLocators to vtkm_cont These changes caused some warnings in clang to show up based on virtual methods in other cell locators. Hence, the rest of the cell locators have also had some of their code moved to vtkm_cont.
2019-03-20 23:38:50 +00:00
CellLocatorUniformGrid.cxx
Add more vtkm_cont compilation units to device_sources. These depend on DeviceAdapterTagCuda::IsEnabled being correctly set at compile time.
2019-03-13 17:58:35 +00:00
CellSet.cxx
Build CellSetExplicit.cxx for devices
2017-08-14 14:19:34 +00:00
CellSetExplicit.cxx
First Extrude commit. how did any of this work? match other CellSet file layouts. ??? compile in CUDA. unit tests. also only serial. make error message accurate Well, this compiles and works now. Did it ever? use CellShapeTagGeneric UnitTest matches previous changes. whoops Fix linking problems. Need the same interface as other ThreadIndices. add filter test okay, let's try duplicating CellSetStructure. okay inching... change to wedge in CellSetListTag Means changing these to support it. switch back to wedge from generic compiles and runs remove ExtrudedType need vtkm_worklet vtkm_worklet needs to be included fix segment count for wedge specialization need to actually save the index for the other constructor. specialize on Explicit clean up warning angled brackets not quotes. formatting
2019-06-06 18:43:53 +00:00
CellSetExtrude.cxx
Add more vtkm_cont compilation units to device_sources. These depend on DeviceAdapterTagCuda::IsEnabled being correctly set at compile time.
2019-03-13 17:58:35 +00:00
CellSetStructured.cxx
ColorTable.cxx
Precompile ConvertNumComponentsToOffsets `ConvertNumComponentsToOffsets` has been changed to provide a pre- compiled version for common arrays. This helps with the dual goals of compiling less device code and allowing data set builders to not have to use the device compiler. For cases where you need to compile `ConvertNumComponentsToOffsets` for a different kind of array, you can use the internal `ConvertNumComponentsToOffsetsTemplate`.
2021-09-16 20:02:36 +00:00
ConvertNumComponentsToOffsets.cxx
Update CoordinateSystem to use the Virtual Array
2017-12-12 19:26:23 +00:00
CoordinateSystem.cxx
Add more vtkm_cont compilation units to device_sources. These depend on DeviceAdapterTagCuda::IsEnabled being correctly set at compile time.
2019-03-13 17:58:35 +00:00
DataSet.cxx
Add helper class to build curvilinear datasets.
2021-06-09 17:50:01 +00:00
DataSetBuilderCurvilinear.cxx
Add more vtkm_cont compilation units to device_sources. These depend on DeviceAdapterTagCuda::IsEnabled being correctly set at compile time.
2019-03-13 17:58:35 +00:00
DataSetBuilderExplicit.cxx
DataSetBuilderRectilinear.cxx
DataSetBuilderUniform.cxx
Field.cxx
FieldRangeCompute.cxx
FieldRangeGlobalCompute.cxx
`MultiBlock` renamed to `PartitionedDataSet` The `MultiBlock` class has been renamed to `PartitionedDataSet`, and its API has been refactored to refer to "partitions", rather than "blocks". Additionally, the `AddBlocks` method has been changed to `AppendPartitions` to more accurately reflect the operation performed. The associated `AssignerMultiBlock` class has also been renamed to `AssignerPartitionedDataSet`. This change is motivated towards unifying VTK-m's data model with VTK. VTK has started to move away from `vtkMultiBlockDataSet`, which is a hierarchical tree of nested datasets, to `vtkPartitionedDataSet`, which is always a flat vector of datasets used to assist geometry distribution in multi-process environments. This simplifies traversal during processing and clarifies the intent of the container: The component datasets are partitions for distribution, not organizational groupings (e.g. materials). Ref #405
2019-09-02 14:38:47 +00:00
PartitionedDataSet.cxx
Rename PointLocatorUniformGrid to PointLocatorSparseGrid The new name reflects better what the underlying algorithm does. It also helps prevent confusion about what types of data the locator is good for. The old name suggested it only worked for structured grids, which is not the case.
2020-09-21 20:49:03 +00:00
PointLocatorSparseGrid.cxx
Less vtkm_cont cxx files bring in the cuda device When you have CUDA enabled we need to make sure that all worklet launches come from a cuda file otherwise we will generate ODR violations.
2019-03-29 18:45:10 +00:00
RuntimeDeviceInformation.cxx
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 and each GetElapsedTime() function call will call Stop() function if it hasn't been called yet for keeping backward compatibility purpose. Bascially it can be used in two modes: * Create a Timer without any device info. vtkm::cont::Timer time; * It would enable timers 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. * Create a Timer with a device id. vtkm::cont::Timer time((vtkm::cont::DeviceAdapterTagCuda())); * It works as the old timer that times for a specific device id.
2019-01-09 16:11:49 +00:00
Timer.cxx
Add UnknownArrayHandle
2020-08-05 03:16:29 +00:00
UnknownArrayHandle.cxx
Compile RuntimeDeviceTracker.cxx with CUDA when appropriate 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.
2017-02-22 23:18:23 +00:00
)
Optionally remove all use of ArrayHandleVirtual As we remove more and more virtual methods from VTK-m, I expect several users will be interested in completely removing them from the build for several reasons. 1. They may be compiling for hardware that does not support virtual methods. 2. They may need to compile for CUDA but need shared libraries. 3. It should go a bit faster. To enable this, a CMake option named `VTKm_NO_DEPRECATED_VIRTUAL` is added. It defaults to `OFF`. But when it is `ON`, none of the code that both uses virtuals and is deprecated will be built. Currently, only `ArrayHandleVirtual` is deprecated, so the rest of the virtual classes will still be built. As we move forward, more will be removed until all virtual method functionality is removed.
2020-09-03 19:54:24 +00:00
if (NOT VTKm_NO_DEPRECATED_VIRTUAL)
set(headers ${headers}
ArrayHandleVirtual.h
ArrayHandleVirtualCoordinates.h
Remove virtual methods from cell locators Deprecated the `CellLocator` class and made all methods of the other `CellLocator` classes non-virtual. General locators can still use the `CellLocatorGeneral` class, but this class now only works with a predefined set of locators. (The functionality to provide a function to select a locator has been removed.)
2020-09-22 15:32:01 +00:00
CellLocator.h
implement PointLocator without virtual methods
2020-11-11 22:02:10 +00:00
PointLocator.h
Optionally remove all use of ArrayHandleVirtual As we remove more and more virtual methods from VTK-m, I expect several users will be interested in completely removing them from the build for several reasons. 1. They may be compiling for hardware that does not support virtual methods. 2. They may need to compile for CUDA but need shared libraries. 3. It should go a bit faster. To enable this, a CMake option named `VTKm_NO_DEPRECATED_VIRTUAL` is added. It defaults to `OFF`. But when it is `ON`, none of the code that both uses virtuals and is deprecated will be built. Currently, only `ArrayHandleVirtual` is deprecated, so the rest of the virtual classes will still be built. As we move forward, more will be removed until all virtual method functionality is removed.
2020-09-03 19:54:24 +00:00
StorageVirtual.h
Do not declare headers for virtual classes that are removed
2021-04-28 20:37:10 +00:00
VirtualObjectHandle.h
Optionally remove all use of ArrayHandleVirtual As we remove more and more virtual methods from VTK-m, I expect several users will be interested in completely removing them from the build for several reasons. 1. They may be compiling for hardware that does not support virtual methods. 2. They may need to compile for CUDA but need shared libraries. 3. It should go a bit faster. To enable this, a CMake option named `VTKm_NO_DEPRECATED_VIRTUAL` is added. It defaults to `OFF`. But when it is `ON`, none of the code that both uses virtuals and is deprecated will be built. Currently, only `ArrayHandleVirtual` is deprecated, so the rest of the virtual classes will still be built. As we move forward, more will be removed until all virtual method functionality is removed.
2020-09-03 19:54:24 +00:00
)
set(template_sources ${template_sources}
ArrayHandleVirtual.hxx
StorageVirtual.hxx
)
set(device_sources ${device_sources}
ArrayHandleVirtual.cxx
Remove virtual methods from cell locators Deprecated the `CellLocator` class and made all methods of the other `CellLocator` classes non-virtual. General locators can still use the `CellLocatorGeneral` class, but this class now only works with a predefined set of locators. (The functionality to provide a function to select a locator has been removed.)
2020-09-22 15:32:01 +00:00
CellLocator.cxx
Completely deprecate virtual methods Deprecate `VirtualObjectHandle` and all other classes that are used to implement objects with virtual methods in the execution environment. Additionally, the code is updated so that if the `VTKm_NO_DEPRECATED_VIRTUAL` flag is set none of the code is compiled at all. This opens us up to opportunities that do not work with virtual methods such as backends that do not support virtual methods and dynamic libraries for CUDA.
2021-04-23 20:07:11 +00:00
internal/TransferInfo.cxx
internal/VirtualObjectTransfer.cxx
implement PointLocator without virtual methods
2020-11-11 22:02:10 +00:00
PointLocator.cxx
Optionally remove all use of ArrayHandleVirtual As we remove more and more virtual methods from VTK-m, I expect several users will be interested in completely removing them from the build for several reasons. 1. They may be compiling for hardware that does not support virtual methods. 2. They may need to compile for CUDA but need shared libraries. 3. It should go a bit faster. To enable this, a CMake option named `VTKm_NO_DEPRECATED_VIRTUAL` is added. It defaults to `OFF`. But when it is `ON`, none of the code that both uses virtuals and is deprecated will be built. Currently, only `ArrayHandleVirtual` is deprecated, so the rest of the virtual classes will still be built. As we move forward, more will be removed until all virtual method functionality is removed.
2020-09-03 19:54:24 +00:00
StorageVirtual.cxx
)
endif()
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
#-----------------------------------------------------------------------------
Enable changing policy used for library compiles Previously, the PolicyDefault used to compile all the filters was hard- coded. The problem was that if any external project that depends on VTK- m needs a different policy, it had to recompile everything in its own translation units with a custom policy. This change allows an external project provide a simple header file that changes the type lists used in the default policy. That allows VTK-m to compile the filters exactly as specified by the external project.
2020-03-17 23:22:35 +00:00
# Set up default types, which can be custom configured by other build systems.
vtkm_get_kit_name(kit_name kit_dir)
# Some custom types included with VTK-m
Add types appropriate for Ascent
2020-12-10 18:46:47 +00:00
vtkm_option(VTKm_USE_DEFAULT_TYPES_FOR_VTK
"Compile VTK-m algorithms for use with types from VTK."
OFF
)
Enable changing policy used for library compiles Previously, the PolicyDefault used to compile all the filters was hard- coded. The problem was that if any external project that depends on VTK- m needs a different policy, it had to recompile everything in its own translation units with a custom policy. This change allows an external project provide a simple header file that changes the type lists used in the default policy. That allows VTK-m to compile the filters exactly as specified by the external project.
2020-03-17 23:22:35 +00:00
if (VTKm_USE_DEFAULT_TYPES_FOR_VTK)
set(VTKm_DEFAULT_TYPES_HEADER "internal/DefaultTypesVTK.h.in")
add XGC storage tags to DefaultTypesVTK
2020-12-15 19:00:24 +00:00
vtkm_option(VTKm_ADD_XGC_TO_DEFAULT_TYPES_VTK "Add XGC types to default VTK types." OFF)
mark_as_advanced(VTKm_ADD_XGC_TO_DEFAULT_TYPES_VTK)
if (VTKm_ADD_XGC_TO_DEFAULT_TYPES_VTK)
set(VTKM_ADD_XGC_DEFAULT_TYPES TRUE)
endif()
Enable changing policy used for library compiles Previously, the PolicyDefault used to compile all the filters was hard- coded. The problem was that if any external project that depends on VTK- m needs a different policy, it had to recompile everything in its own translation units with a custom policy. This change allows an external project provide a simple header file that changes the type lists used in the default policy. That allows VTK-m to compile the filters exactly as specified by the external project.
2020-03-17 23:22:35 +00:00
endif()
Add types appropriate for Ascent
2020-12-10 18:46:47 +00:00
vtkm_option(VTKm_USE_DEFAULT_TYPES_FOR_ASCENT
"Compile VTK-m algorithms for use with types from Ascent."
OFF
)
if (VTKm_USE_DEFAULT_TYPES_FOR_ASCENT)
set(VTKm_DEFAULT_TYPES_HEADER "internal/DefaultTypesAscent.h.in")
if (VTKm_USE_64BIT_IDS)
message(SEND_ERROR
"When VTKm_USE_DEFAULT_TYPES_FOR_ASCENT is ON, VTKm_USE_64BIT_IDS must be set to OFF"
)
endif()
if (NOT VTKm_USE_DOUBLE_PRECISION)
message(SEND_ERROR
"When VTKm_USE_DEFAULT_TYPES_FOR_ASCENT is ON, VTKm_USE_DOUBLE_PRECISION must be set to ON"
)
endif()
endif()
mark_as_advanced(
VTKm_USE_DEFAULT_TYPES_FOR_VTK
VTKm_USE_DEFAULT_TYPES_FOR_ASCENT
)
Enable changing policy used for library compiles Previously, the PolicyDefault used to compile all the filters was hard- coded. The problem was that if any external project that depends on VTK- m needs a different policy, it had to recompile everything in its own translation units with a custom policy. This change allows an external project provide a simple header file that changes the type lists used in the default policy. That allows VTK-m to compile the filters exactly as specified by the external project.
2020-03-17 23:22:35 +00:00
if (VTKm_DEFAULT_TYPES_HEADER)
set(VTK_M_HAS_DEFAULT_TYPES_HEADER TRUE)
get_filename_component(VTKm_DEFAULT_TYPES_HEADER_FILENAME ${VTKm_DEFAULT_TYPES_HEADER} NAME_WE)
set(VTKm_DEFAULT_TYPES_HEADER_FILENAME "${VTKm_DEFAULT_TYPES_HEADER_FILENAME}.h")
configure_file(${VTKm_DEFAULT_TYPES_HEADER}
${VTKm_BINARY_INCLUDE_DIR}/${kit_dir}/internal/${VTKm_DEFAULT_TYPES_HEADER_FILENAME}
@ONLY
)
vtkm_install_headers(vtkm/cont/internal
${VTKm_BINARY_INCLUDE_DIR}/${kit_dir}/internal/${VTKm_DEFAULT_TYPES_HEADER_FILENAME}
)
endif()
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/DefaultTypes.h.in
${VTKm_BINARY_INCLUDE_DIR}/${kit_dir}/DefaultTypes.h
@ONLY
)
vtkm_install_headers(vtkm/cont
${VTKm_BINARY_INCLUDE_DIR}/${kit_dir}/DefaultTypes.h
)
#-----------------------------------------------------------------------------
Simplify how we built the list of source files for vtkm_cont
2018-01-17 22:13:50 +00:00
vtkm_library( NAME vtkm_cont
SOURCES ${sources}
TEMPLATE_SOURCES ${template_sources}
HEADERS ${headers}
vtkm_library WRAP_FOR_CUDA renamed to clarify the intent of the property We want the option name to be clear that it might be applicable for more than just CUDA. If VTK-m ever supported something like SYCL it would not be clear that those sources should go in `WRAP_FOR_CUDA`.
2019-07-08 18:09:09 +00:00
DEVICE_SOURCES ${device_sources}
Simplify how we built the list of source files for vtkm_cont
2018-01-17 22:13:50 +00:00
)
Enable Separable Compilation for CUDA
2018-08-16 20:34:44 +00:00
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
add_subdirectory(internal)
Add Transport class The Transport class is responsible for moving data from the control environment to the execution environment. (Actually, it might be more accurate to say it gets the execution environment associated with a given control object.) The Transport class is templated with a tag that controls the mechanism used for the transport.
2014-10-14 16:44:48 +00:00
add_subdirectory(arg)
Add vtkm/cont/serial directory for the serial backend.
2016-09-28 15:38:31 +00:00
add_subdirectory(serial)
Add TaskTiling1D/3D which use faux virtuals to reduce binary size. Redesigns the TBB and Serial backends and the vtkm::exec::Task concept so that we can re-use the same launching logic for all Worklets, instead of generating per worlet code. To keep the performance the same the TilingTask now is past a range of indices to work on, rather than a single index. Binary size reduction: WorkletTests_SERIAL old - 19MB WorkletTests_SERIAL new - 18MB WorkletTests_TBB old - 39MB WorkletTests_TBB new - 18MB libvtkAcceleratorsVTKm old - 48MB libvtkAcceleratorsVTKm new - 19MB
2016-09-12 14:30:03 +00:00
add_subdirectory(tbb)
Add initial version of an OpenMP backend.
2018-03-01 21:20:31 +00:00
add_subdirectory(openmp)
Simplify how we built the list of source files for vtkm_cont
2018-01-17 22:13:50 +00:00
add_subdirectory(cuda)
Add Kokkos backend
2020-06-16 12:54:01 +00:00
add_subdirectory(kokkos)
Simplify how we built the list of source files for vtkm_cont
2018-01-17 22:13:50 +00:00
set(backends )
Prefer using existence of targets when looking for TBB/CUDA support
2017-12-29 18:16:52 +00:00
if(TARGET vtkm::tbb)
Update all the code to work with CMake 3.3 Obviously this does mean that CUDA is not supported with 3.3.
2017-10-05 17:24:47 +00:00
list(APPEND backends vtkm::tbb)
Add TaskTiling1D/3D which use faux virtuals to reduce binary size. Redesigns the TBB and Serial backends and the vtkm::exec::Task concept so that we can re-use the same launching logic for all Worklets, instead of generating per worlet code. To keep the performance the same the TilingTask now is past a range of indices to work on, rather than a single index. Binary size reduction: WorkletTests_SERIAL old - 19MB WorkletTests_SERIAL new - 18MB WorkletTests_TBB old - 39MB WorkletTests_TBB new - 18MB libvtkAcceleratorsVTKm old - 48MB libvtkAcceleratorsVTKm new - 19MB
2016-09-12 14:30:03 +00:00
endif()
Prefer using existence of targets when looking for TBB/CUDA support
2017-12-29 18:16:52 +00:00
if(TARGET vtkm::cuda)
Update all the code to work with CMake 3.3 Obviously this does mean that CUDA is not supported with 3.3.
2017-10-05 17:24:47 +00:00
list(APPEND backends vtkm::cuda)
Get the vtkm cont cuda object to compile properly.
2017-03-06 14:41:40 +00:00
endif()
Add initial version of an OpenMP backend.
2018-03-01 21:20:31 +00:00
if(TARGET vtkm::openmp)
list(APPEND backends vtkm::openmp)
endif()
Add Kokkos backend
2020-06-16 12:54:01 +00:00
if(TARGET vtkm::kokkos)
list(APPEND backends vtkm::kokkos)
endif()
Cleanup logic surrounding the usage of vtkm thirdparty libraries
2019-06-18 19:20:24 +00:00
target_link_libraries(vtkm_cont PUBLIC vtkm_compiler_flags ${backends})
Add threads library to vtkm_cont With the new thread safety/token code, the vtkm_cont library now relies on the pthreads library (or whatever threads library is used by std on the system). Make sure this library gets added to vtkm_cont.
2020-01-30 17:07:59 +00:00
target_link_libraries(vtkm_cont PUBLIC Threads::Threads)
Remove tao tuple from third party libraries We are no longer using this code. It has been replaced by vtkm::Tuple.
2020-03-04 22:26:09 +00:00
target_link_libraries(vtkm_cont PUBLIC vtkm_optionparser vtkm_diy vtkm_lcl)
Make sure vtkm_cont links to vtkm_loguru when logging enabled
2019-06-19 13:52:43 +00:00
if(TARGET vtkm_loguru)
target_link_libraries(vtkm_cont PRIVATE vtkm_loguru)
endif()
Making vtkm-cont depend on diy.
2017-11-28 21:04:15 +00:00
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
#-----------------------------------------------------------------------------
CMake: adds VTKm_ENABLE_TESTING_LIB
2021-09-22 19:51:36 +00:00
if(VTKm_ENABLE_TESTING_LIBRARY)
cmake: avoid adding testing directories if testing is disabled Some testing directories have side effects such as installing headers or compiling code that ultimately doesn't end up getting used.
2021-06-01 22:38:19 +00:00
add_subdirectory(testing)
CMake: adds VTKm_ENABLE_TESTING_LIB
2021-09-22 19:51:36 +00:00
endif()
Reference in New Issue Copy Permalink