c16236ce69
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. |
||
|---|---|---|
| CMake | ||
| data | ||
| docs | ||
| examples | ||
| Utilities/Git | ||
| vtkm | ||
| .gitattributes | ||
| CMakeLists.txt | ||
| CONTRIBUTING.md | ||
| CTestConfig.cmake | ||
| CTestCustom.cmake.in | ||
| LICENSE.txt | ||
| README.md | ||
| version.txt | ||
VTK-m
One of the biggest recent changes in high-performance computing is the increasing use of accelerators. Accelerators contain processing cores that independently are inferior to a core in a typical CPU, but these cores are replicated and grouped such that their aggregate execution provides a very high computation rate at a much lower power. Current and future CPU processors also require much more explicit parallelism. Each successive version of the hardware packs more cores into each processor, and technologies like hyperthreading and vector operations require even more parallel processing to leverage each core’s full potential.
VTK-m is a toolkit of scientific visualization algorithms for emerging processor architectures. VTK-m supports the fine-grained concurrency for data analysis and visualization algorithms required to drive extreme scale computing by providing abstract models for data and execution that can be applied to a variety of algorithms across many different processor architectures.
Getting VTK-m
The VTK-m repository is located at https://gitlab.kitware.com/vtk/vtk-m
VTK-m required dependencies are:
VTK-m optional dependencies are:
git clone https://gitlab.kitware.com/vtk/vtk-m.git vtkm
mkdir vtkm-build
cd vtkm-build
cmake-gui ../vtkm
A detailed walk-through of installing and building VTK-m can be found on our Contributing page