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
5aba6e1bea
vtk-m/vtkm/cont/CMakeLists.txt

290 lines
7.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
Make ArrayCopy not depend on a device compiler Rather than require `ArrayCopy` to create special versions of copy for all arrays, use a precompiled versions. This should speed up compiles, reduce the amount of code being generated, and require the device compiler on fewer source files. There are some cases where you still need to copy arrays that are not well supported by the precompiled versions in `ArrayCopy`. (It will always work, but the fallback is very slow.) In this case, you will want to switch over to `ArrayCopyDevice`, which has the old behavior.
2022-01-05 21:46:37 +00:00
ArrayCopyDevice.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
add partitioned cell locator
2022-11-01 10:08:18 +00:00
CellLocatorPartitioned.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
Add a new unstructured cell locator
2022-11-22 14:51:40 +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
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
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
Move DeviceAdapterTag to vtkm/cont
2019-04-03 20:28:31 +00:00
DeviceAdapterTag.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 Abort execution feature Initial changes to add support for aborting execution.
2023-02-01 15:58:01 +00:00
ErrorUserAbort.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
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
add merge partitioned dataset capability
2021-10-18 21:37:13 +00:00
MergePartitionedDataSet.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
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
Convert uses of ListTagBase to List
2019-12-05 21:38:41 +00:00
StorageList.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 UncertainCellSet This is a replacement for DynamicCellSet that requires less templating.
2021-12-13 21:04:43 +00:00
UncertainCellSet.h
Add UnknownArrayHandle
2020-08-05 03:16:29 +00:00
UnknownArrayHandle.h
Add UncertainCellSet This is a replacement for DynamicCellSet that requires less templating.
2021-12-13 21:04:43 +00:00
UnknownCellSet.h
Expose the Variant helper class For several versions, VTK-m has had a `Variant` templated class. This acts like a templated union where the object will store one of a list of types specified as the template arguments. (There are actually 2 versions for the control and execution environments, respectively.) Because this is a complex class that required several iterations to work through performance and compiler issues, `Variant` was placed in the `internal` namespace to avoid complications with backward compatibility. However, the class has been stable for a while, so let us expose this helpful tool for wider use.
2022-11-01 13:52:41 +00:00
Variant.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
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
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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
AssignerPartitionedDataSet.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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
BoundsCompute.cxx
BoundsGlobalCompute.cxx
CellLocatorGeneral.cxx
add partitioned cell locator
2022-11-01 10:08:18 +00:00
CellLocatorPartitioned.cxx
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
CellLocatorRectilinearGrid.cxx
Add a new unstructured cell locator
2022-11-22 14:51:40 +00:00
CellLocatorUniformBins.cxx
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
CellLocatorUniformGrid.cxx
CellSet.cxx
CellSetStructured.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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
CoordinateSystem.cxx
DataSet.cxx
DataSetBuilderCurvilinear.cxx
DataSetBuilderExplicit.cxx
DataSetBuilderRectilinear.cxx
DataSetBuilderUniform.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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
FieldRangeCompute.cxx
FieldRangeGlobalCompute.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/DeviceAdapterMemoryManager.cxx
internal/DeviceAdapterMemoryManagerShared.cxx
Create FieldCollection class.
2022-08-22 19:02:03 +00:00
internal/FieldCollection.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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
PartitionedDataSet.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
Compile more sources without device compiler We have been doing a better job at hiding device code (and moving code into libraries). Smoke out source that no longer needs to be compiled by device compilers.
2021-08-12 20:48:39 +00:00
UnknownArrayHandle.cxx
Add UncertainCellSet This is a replacement for DynamicCellSet that requires less templating.
2021-12-13 21:04:43 +00:00
UnknownCellSet.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
Add ArrayCopy specialization for Counting and Permutation array This required adding another source file.
2022-01-14 21:04:18 +00:00
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
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
Update CMakeLists.txt
2022-11-22 15:48:29 +00:00
CellLocatorUniformBins.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
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
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
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
Field.cxx
Make ArrayCopy not depend on a device compiler Rather than require `ArrayCopy` to create special versions of copy for all arrays, use a precompiled versions. This should speed up compiles, reduce the amount of code being generated, and require the device compiler on fewer source files. There are some cases where you still need to copy arrays that are not well supported by the precompiled versions in `ArrayCopy`. (It will always work, but the fallback is very slow.) In this case, you will want to switch over to `ArrayCopyDevice`, which has the old behavior.
2022-01-05 21:46:37 +00:00
internal/ArrayCopyUnknown.cxx
Add ability to fill values in a Buffer This is in preparation to add a method to `ArrayHandle` that allows initializing fill values.
2021-11-22 21:52:41 +00:00
internal/Buffer.cxx
Implement permutation mapping in vtkm_cont There was a precompiled version of mapping permutations in the filter library. However, there are reasons to be able to copy a permutation of an array outside of filters. So add the capability to the more general filter library.
2022-01-14 15:33:46 +00:00
internal/MapArrayPermutation.cxx
remove unnecessary includes and change to device_sources
2021-10-29 21:10:04 +00:00
MergePartitionedDataSet.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
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
)
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)
Simplify how we built the list of source files for vtkm_cont
2018-01-17 22:13:50 +00:00
set(backends )
cmake: namespace vtkm export targets
2022-12-09 23:46:56 +00:00
if(TARGET vtkm_tbb)
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()
cmake: namespace vtkm export targets
2022-12-09 23:46:56 +00:00
if(TARGET vtkm_cuda)
list(APPEND backends vtkm_cuda)
Get the vtkm cont cuda object to compile properly.
2017-03-06 14:41:40 +00:00
endif()
cmake: namespace vtkm export targets
2022-12-09 23:46:56 +00:00
if(TARGET vtkm_openmp)
list(APPEND backends vtkm_openmp)
Add initial version of an OpenMP backend.
2018-03-01 21:20:31 +00:00
endif()
CMAKE: fix vtkm devices namespaces
2022-12-26 18:40:12 +00:00
if(TARGET vtkm_kokkos)
list(APPEND backends vtkm_kokkos)
Add Kokkos backend
2020-06-16 12:54:01 +00:00
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)
Reference in New Issue Copy Permalink