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

168 lines
4.3 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.
##
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
## Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
## 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
##
Update copyright for Sandia Sandia National Laboratories recently changed management from the Sandia Corporation to the National Technology & Engineering Solutions of Sandia, LLC (NTESS). The copyright statements need to be updated accordingly.
2017-09-20 21:33:44 +00:00
## Under the terms of Contract DE-NA0003525 with NTESS,
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
## 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
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 in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
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 ArrayHandleExtractComponent. This is part of #43, which will ultimately simplify the ArrayHandleCompositeVector to a new implementation that can be easily written to. Part of this effort will remove the ability to pull a single component from a vector-typed input ArrayHandle for use in the CompositeVector, and this new class makes sure we can still support that usecase.
2017-07-26 20:59:48 +00:00
ArrayHandleExtractComponent.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
add ArrayHandleReverse.h in CMakeLists.txt
2017-05-08 17:49:18 +00:00
ArrayHandleReverse.h
Adding ArrayHandleStreaming to CMake and fixing warnings
2016-08-19 19:47:44 +00:00
ArrayHandleStreaming.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 ArrayHandleVirtualCoordinates
2017-12-12 15:15:20 +00:00
ArrayHandleVirtualCoordinates.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
Use `diy::reduce` in MultiBlock reductions. MultiBlock now uses `diy::reduce` for reductions rather than using proxy collectives. To support using `diy::reduce` operations on a vtkm::cont::MultiBlock, added AssignerMultiBlock and DecomposerMultiBlock classes. This are helper classes that provide DIY concepts on top of a existing MultiBlock.
2017-12-21 01:18:22 +00:00
AssignerMultiBlock.h
Add a CellLocator Implements a two-level uniform grid cell locator
2017-09-28 20:45:51 +00:00
CellLocatorTwoLevelUniformGrid.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
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
Use `diy::reduce` in MultiBlock reductions. MultiBlock now uses `diy::reduce` for reductions rather than using proxy collectives. To support using `diy::reduce` operations on a vtkm::cont::MultiBlock, added AssignerMultiBlock and DecomposerMultiBlock classes. This are helper classes that provide DIY concepts on top of a existing MultiBlock.
2017-12-21 01:18:22 +00:00
DecomposerMultiBlock.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 `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
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
Switch from faux to true virtuals
2017-10-23 13:38:33 +00:00
ImplicitFunctionHandle.h
fixing test error
2017-05-11 19:20:01 +00:00
MultiBlock.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
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
Switch from faux to true virtuals
2017-10-23 13:38:33 +00:00
VirtualObjectHandle.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
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
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
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
Use `diy::reduce` in MultiBlock reductions. MultiBlock now uses `diy::reduce` for reductions rather than using proxy collectives. To support using `diy::reduce` operations on a vtkm::cont::MultiBlock, added AssignerMultiBlock and DecomposerMultiBlock classes. This are helper classes that provide DIY concepts on top of a existing MultiBlock.
2017-12-21 01:18:22 +00:00
AssignerMultiBlock.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
CellSet.cxx
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.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
CellSetStructured.cxx
CoordinateSystem.cxx
Build vtkm::cont::DataSet into the vtkm_cont library.
2017-12-19 20:14:30 +00:00
DataSet.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
DynamicArrayHandle.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
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
Field.cxx
internal/SimplePolymorphicContainer.cxx
Expand MultiBlock Functionality
2017-07-20 19:11:12 +00:00
MultiBlock.cxx
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
internal/ArrayManagerExecutionShareWithControl.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
Build CellSetExplicit.cxx for devices
2017-08-14 14:19:34 +00:00
CellSetExplicit.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
Rework TryExecute to leverage perfect forwarding. By using perfect forwarding we can reduce not only the amount of TryExecute signatures, but we can enable the ability to pass temporary functors to TryExecute. At the same time we have optimized TryExecute by moving the string generation code into a single function that is compiled into the vtkm_cont library. The end result is that the vtkm_rendering library size has been reduced from 12MB to 11MB, and we shave off about 5% of our build time.
2017-11-07 19:17:28 +00:00
TryExecute.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 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
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_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
Add vtkm/cont/serial directory for the serial backend.
2016-09-28 15:38:31 +00:00
add_subdirectory(serial)
First pass at compiling ArrayHandle into vtkm_cont.
2017-04-05 22:45:01 +00:00
set(sources ${sources} $<TARGET_OBJECTS:vtkm_cont_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)
if (VTKm_ENABLE_TBB)
set(sources ${sources} $<TARGET_OBJECTS:vtkm_cont_tbb>)
endif()
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)
First pass at compiling ArrayHandle into vtkm_cont.
2017-04-05 22:45:01 +00:00
if (VTKm_ENABLE_CUDA)
Get the vtkm cont cuda object to compile properly.
2017-03-06 14:41:40 +00:00
get_property(vtkm_cont_cuda_object_files GLOBAL
PROPERTY vtkm_cont_cuda_object_files )
# mark the file as generated, this needs to be done in this directory
# for 'reasons'.
set_source_files_properties(${vtkm_cont_cuda_object_files}
PROPERTIES GENERATED TRUE)
set(sources ${sources} ${vtkm_cont_cuda_object_files})
First pass at compiling ArrayHandle into vtkm_cont.
2017-04-05 22:45:01 +00:00
endif()
vtkm_library(
SOURCES ${sources}
WRAP_FOR_CUDA ${device_sources}
HEADERS ${header_impls})
target_include_directories(vtkm_cont PRIVATE ${VTKm_BACKEND_INCLUDE_DIRS})
Add in the minimum part of the control env to have a testable array handle.
2014-02-10 19:53:03 +00:00
Get the vtkm cont cuda object to compile properly.
2017-03-06 14:41:40 +00:00
if(VTKm_ENABLE_CUDA)
add_dependencies(vtkm_cont vtkm_cont_cuda)
endif()
Making vtkm-cont depend on diy.
2017-11-28 21:04:15 +00:00
if(VTKm_ENABLE_MPI)
# This will become a required dependency eventually.
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
target_link_libraries(vtkm_cont PUBLIC diy)
Making vtkm-cont depend on diy.
2017-11-28 21:04:15 +00:00
endif()
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