Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-08 11:29:02 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
master
vtk-m/vtkm/cont/internal/CMakeLists.txt

50 lines
1.5 KiB
CMake
Raw Permalink 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
Add copy methods to `UnknownArrayHandle` `vtkm::cont::UnknownArrayHandle` now provides a set of method that allows you to copy data from one `UnknownArrayHandle` to another. The first method, `DeepCopyFrom`, takes a source `UnknownArrayHandle` and deep copies the data to the called one. If the `UnknownArrayHandle` already points to a real `ArrayHandle`, the data is copied into that `ArrayHandle`. If the `UnknownArrayHandle` does not point to an existing `ArrayHandle`, then a new `ArrayHandleBasic` with the same value type as the source is created and copied into. The second method, `CopyShallowIfPossibleFrom` behaves similarly to `DeepCopyFrom` except that it will perform a shallow copy if possible. That is, if the target `UnknownArrayHandle` points to an `ArrayHandle` of the same type as the source `UnknownArrayHandle`, then a shallow copy occurs and the underlying `ArrayHandle` will point to the source. If the types differ, then a deep copy is performed. If the target `UnknownArrayHandle` does not point to an `ArrayHandle`, then the behavior is the same as the `=` operator. One of the intentions of these new methods is to allow you to copy arrays without using a device compiler (e.g. `nvcc`). Calling `ArrayCopy` requires you to include the `ArrayCopy.h` header file, and that in turn requires device adapter algorithms. These methods insulate you from these.
2021-09-28 16:46:41 +00:00
ArrayCopyUnknown.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
ArrayHandleExecutionManager.h
ArrayPortalFromIterators.h
Advanced Compute Range Add support for masks, vector magnitude range (L2 norm), and finite values only range computations.
2023-06-02 12:23:03 +00:00
ArrayRangeComputeUtils.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
ArrayTransfer.h
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
Buffer.h
Enable setting invalid value in probe filter Initially, the probe filter would simply not set a value if a sample was outside the input `DataSet`. This is not great as the memory could be left uninitalized and lead to unpredictable results. The testing compared these invalid results to 0, which seemed to work but is probably unstable. This was partially fixed by a previous change that consolidated to mapping of cell data with a general routine that permuted data. However, the fix did not extend to point data in the input, and it was not possible to specify a particular invalid value. This change specifically updates the probe filter so that invalid values are set to a user-specified value.
2020-06-03 21:24:36 +00:00
CastInvalidValue.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
CellLocatorBase.h
Reintroduce explicit connectivity class for cont environment (Re-) Add a helper structure that holds the connectivity information for a particular topology connection (e.g. from points to cells) to make it easier to manage connections in multiple different directions in CellSetExplicit. Unlike the previous version of connectivity, this structure is considered "internal" and not exposed through the API so that CellSetExplicit can better manage the data. Also, many of the helper methods remain in CellSetExplicit since they were specific for point-to- Also, CellSetExplicit has a mechanism to take an arbitrary pair of TopologyElementTags and get the appropriate connectivity. This should simplify adding connections in the future.
2015-08-11 18:42:34 +00:00
ConnectivityExplicitInternals.h
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
ConvertNumComponentsToOffsetsTemplate.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
DeviceAdapterAlgorithmGeneral.h
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
DeviceAdapterMemoryManager.h
DeviceAdapterMemoryManagerShared.h
Make ForEachValidDevice internal * Add FindDeviceAdapterTagAndCall * Add support for multiple arguments to be passed to the functor in 'ForEachValidDevice' and 'FindDeviceAdapterTagAndCall'.
2017-12-12 19:12:02 +00:00
DeviceAdapterListHelpers.h
Create FieldCollection class.
2022-08-22 19:02:03 +00:00
FieldCollection.h
Move algorithms out of DeviceAdapterAlgorithmGeneral to reduce compilation size
2015-07-16 19:40:22 +00:00
FunctorsGeneral.h
Add hints to device adapter scheduler The `DeviceAdapter` provides an abstract interface to the accelerator devices worklets and other algorithms run on. As such, the programmer has less control about how the device launches each worklet. Each device adapter has its own configuration parameters and other ways to attempt to optimize how things are run, but these are always a universal set of options that are applied to everything run on the device. There is no way to specify launch parameters for a particular worklet. To provide this information, VTK-m now supports `Hint`s to the device adapter. The `DeviceAdapterAlgorithm::Schedule` method takes a templated argument that is of the type `HintList`. This object contains a template list of `Hint` types that provide suggestions on how to launch the parallel execution. The device adapter will pick out hints that pertain to it and adjust its launching accordingly. These are called hints rather than, say, directives, because they don't force the device adapter to do anything. The device adapter is free to ignore any (and all) hints. The point is that the device adapter can take into account the information to try to optimize for itself. A provided hint can be tied to specific device adapters. In this way, an worklet can further optimize itself. If multiple hints match a device adapter, the last one in the list will be selected. The `Worklet` base now has an internal type named `Hints` that points to a `HintList` that is applied when the worklet is scheduled. Derived worklet classes can provide hints by simply defining their own `Hints` type.
2024-02-06 18:33:33 +00:00
Hints.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
IteratorFromArrayPortal.h
Generalize the TBB radix sort implementation. The core algorithm will be shared by OpenMP.
2018-05-14 19:55:23 +00:00
KXSort.h
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
MapArrayPermutation.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
OptionParser.h
Implement RuntimeDeviceConfiguration
2021-05-26 19:43:36 +00:00
OptionParserArguments.h
Generalize the TBB radix sort implementation. The core algorithm will be shared by OpenMP.
2018-05-14 19:55:23 +00:00
ParallelRadixSort.h
ParallelRadixSortInterface.h
implement PointLocator without virtual methods
2020-11-11 22:02:10 +00:00
PointLocatorBase.h
Reduce computational overhead for reverse connectivity calc. Benchmarking in VTK showed significant overhead in the computation of the reverse connectivity calculation in ConnectivityExplicitInternals::ComputeCellToPointConnectivity. This patch adds a ReverseConnectivityBuilder that reduces the amount of time and memory needed to build the table by using an atomic histogram approach that avoids a costly radix SortByKey. Key operations in the new helper class are templated to allow this approach to be reused by VTK-specific cell array converters.
2018-06-28 16:53:22 +00:00
ReverseConnectivityBuilder.h
Implement RuntimeDeviceConfiguration
2021-05-26 19:43:36 +00:00
RuntimeDeviceConfiguration.h
RuntimeDeviceConfigurationOptions.h
RuntimeDeviceOption.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
StorageError.h
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
)
vtkm_declare_headers(${headers})
# These source files are actually compiled in the parent directory.
# They are in a separate directory to highlight which objects are
# internal and which are part of the external interface.
#add_custom_target(vtkmContInternal ALL DEPENDS vtkmCont)
Reference in New Issue Copy Permalink