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

119 lines
3.0 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.
## This software is distributed WITHOUT ANY WARRANTY; without even
## the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
## PURPOSE. See the above copyright notice for more information.
##
## Copyright 2014 Sandia Corporation.
## Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
## Copyright 2014 Los Alamos National Security.
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
##
## Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
## the U.S. Government retains certain rights in this software.
##
## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
## Laboratory (LANL), the U.S. Government retains certain rights in
## this software.
##============================================================================
set(headers
ArrayHandle.h
Add ArrayHandleCast
2015-09-01 21:42:45 +00:00
ArrayHandleCast.h
Fix compile issues. Add new files to CMakeLists.txt
2015-12-22 17:41:30 +00:00
ArrayHandleCartesianProduct.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
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 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
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
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
Adding ArrayHandleStreaming to CMake and fixing warnings
2016-08-19 19:47:44 +00:00
ArrayHandleStreaming.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 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
add an array handle: ArrayHandleConcatenate
2016-07-15 00:16:57 +00:00
ArrayHandleConcatenate.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
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.hxx
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
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
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
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
CellSetPermutation.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
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
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
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
DynamicArrayHandle.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 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
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
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
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
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
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
StorageBasic.h
StorageImplicit.h
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 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
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
)
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(header_impls
ArrayHandle.hxx
CellSetStructured.hxx
vtkm_cont now contains explicit instantiations of common StorageBasic types.
2016-12-19 13:58:12 +00:00
StorageBasic.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
CellSet.cxx
CellSetStructured.cxx
CoordinateSystem.cxx
DynamicArrayHandle.cxx
Field.cxx
internal/SimplePolymorphicContainer.cxx
vtkm_cont now contains explicit instantiations of common StorageBasic types.
2016-12-19 13:58:12 +00:00
StorageBasic.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
)
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
# 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
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
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
RuntimeDeviceTracker.cxx
)
Support using empty array handles as input Previously if you constructed an array handle without allocating it, you would get an error if you tried to use the array as input. This conflicted with some recent changes to accept empty vectors. Now when you try to use an unallocated ArrayHandle as input (calling PrepareForInput or PrepareForInPlace), it internally calls Allocate(0) (to establish internal state) and sets up a valid execution ArrayPortal of size 0.
2017-02-14 22:27:34 +00:00
vtkm_library(
SOURCES ${sources}
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
WRAP_FOR_CUDA ${device_sources}
Support using empty array handles as input Previously if you constructed an array handle without allocating it, you would get an error if you tried to use the array as input. This conflicted with some recent changes to accept empty vectors. Now when you try to use an unallocated ArrayHandle as input (calling PrepareForInput or PrepareForInPlace), it internally calls Allocate(0) (to establish internal state) and sets up a valid execution ArrayPortal of size 0.
2017-02-14 22:27:34 +00:00
HEADERS ${header_impls})
Fix issues found on dashboard machines.
2017-01-27 15:39:35 +00:00
target_include_directories(vtkm_cont PRIVATE ${VTKm_BACKEND_INCLUDE_DIRS})
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 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 in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
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
vtkm_declare_headers(${headers})
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
Add vtkm/cont/serial directory for the serial backend.
2016-09-28 15:38:31 +00:00
add_subdirectory(serial)
Always install all device headers even when device isn't enabled. vtkm_declare_headers now is able to not test headers, by using the TESTABLE keyword.
2015-09-17 13:23:53 +00:00
add_subdirectory(cuda)
add_subdirectory(tbb)
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
#-----------------------------------------------------------------------------
Attempt 10 to resolve Windows compiler warning with streaming storage
2016-10-21 19:10:49 +00:00
add_subdirectory(testing)
Reference in New Issue Copy Permalink