Split the compilation of ContourMarchingCells into instantiations

Although the contour filter was recently divided into 2 filters, flying
edges and marching cubes, the marching cubes version still had many
conditions and was the file that took the longest to compile on Frontier.
To help speed up parallel compiles and prevent a single run of a
compiler from being overwhelmed, the compilation of all the marching
cubes conditions has been split up using instantiations.

docs/changelog/split-contour-filters.md

@@ -8,4 +8,7 @@ Although `Contour` is still the preferred option for most cases because it selec
 
 Deprecate functions `GetComputeFastNormalsForStructured`, `SetComputeFastNormalsForStructured`, `GetComputeFastNormalsForUnstructured` and `GetComputeFastNormalsForUnstructured`, to use the more general `GetComputeFastNormals` and `SetComputeFastNormals` instead.
 
- By default, for the `Contour` filter, `GenerateNormals` is now `true`, and `ComputeFastNormals` is `false`.
+By default, for the `Contour` filter, `GenerateNormals` is now `true`, and `ComputeFastNormals` is `false`.
+
+The marching cubes version of contour still has several possible compile paths, so it can still take a bit to compile. To help manage the compile time further, the contour filter compilation is broken up even further using the instantiation build capabilities.
+

vtkm/filter/contour/CMakeLists.txt

@@ -34,6 +34,9 @@ set(contour_sources
   Contour.cxx
 )
 
+vtkm_add_instantiations(contour_instantiations INSTANTIATIONS_FILE worklet/ContourMarchingCells.h)
+list(APPEND contour_sources_device ${contour_instantiations})
+
 set_source_files_properties(Contour.cxx PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 
 vtkm_library(

vtkm/filter/contour/ContourMarchingCells.cxx

@@ -59,12 +59,11 @@ vtkm::cont::DataSet ContourMarchingCells::DoExecute(const vtkm::cont::DataSet& i
 
     if (this->GenerateNormals && !this->GetComputeFastNormals())
     {
-      outputCells =
+      outputCells = worklet.Run(ivalues, inputCells, inputCoords, concrete, vertices, normals);
-        worklet.Run(ivalues, inputCells, inputCoords.GetData(), concrete, vertices, normals);
     }
     else
     {
-      outputCells = worklet.Run(ivalues, inputCells, inputCoords.GetData(), concrete, vertices);
+      outputCells = worklet.Run(ivalues, inputCells, inputCoords, concrete, vertices);
     }
   };
 

vtkm/filter/contour/worklet/ContourMarchingCells.h

@@ -11,10 +11,19 @@
 #ifndef vtk_m_worklet_ContourMarchingCells_h
 #define vtk_m_worklet_ContourMarchingCells_h
 
+#include <vtkm/filter/contour/vtkm_filter_contour_export.h>
 #include <vtkm/filter/contour/worklet/contour/CommonState.h>
 #include <vtkm/filter/contour/worklet/contour/FieldPropagation.h>
 #include <vtkm/filter/contour/worklet/contour/MarchingCells.h>
 
+#include <vtkm/cont/CellSetExplicit.h>
+#include <vtkm/cont/CellSetSingleType.h>
+#include <vtkm/cont/CellSetStructured.h>
+#include <vtkm/cont/CoordinateSystem.h>
+#include <vtkm/cont/UnknownCellSet.h>
+
+#include <vtkm/internal/Instantiations.h>
+
 
 namespace vtkm
 {
@@ -22,6 +31,7 @@ namespace worklet
 {
 namespace contour
 {
+
 struct DeduceCoordType
 {
   template <typename CoordinateType, typename CellSetType, typename... Args>
@@ -36,15 +46,41 @@ struct DeduceCoordType
 
 struct DeduceCellType
 {
-  template <typename CellSetType, typename CoordinateType, typename... Args>
+  template <typename CellSetType, typename ValueType, typename StorageTagField>
-  void operator()(const CellSetType& cells, CoordinateType&& coordinateSystem, Args&&... args) const
+  void operator()(const CellSetType& cells,
-  {
+                  const vtkm::cont::CoordinateSystem& coordinateSystem,
-    vtkm::cont::CastAndCall(
+                  vtkm::cont::CellSetSingleType<>& outputCells,
-      coordinateSystem, contour::DeduceCoordType{}, cells, std::forward<Args>(args)...);
+                  const std::vector<ValueType>& isovalues,
-  }
+                  const vtkm::cont::ArrayHandle<ValueType, StorageTagField>& input,
+                  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+                  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+                  vtkm::worklet::contour::CommonState& sharedState) const;
 };
+
+// Declared outside of class, non-inline so that instantiations can be exported correctly.
+template <typename CellSetType, typename ValueType, typename StorageTagField>
+void DeduceCellType::operator()(const CellSetType& cells,
+                                const vtkm::cont::CoordinateSystem& coordinateSystem,
+                                vtkm::cont::CellSetSingleType<>& outputCells,
+                                const std::vector<ValueType>& isovalues,
+                                const vtkm::cont::ArrayHandle<ValueType, StorageTagField>& input,
+                                vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+                                vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+                                vtkm::worklet::contour::CommonState& sharedState) const
+{
+  vtkm::cont::CastAndCall(coordinateSystem,
+                          contour::DeduceCoordType{},
+                          cells,
+                          outputCells,
+                          isovalues,
+                          input,
+                          vertices,
+                          normals,
+                          sharedState);
 }
 
+} // namespace contour
+
 /// \brief Compute the isosurface of a given 3D data set, supports all linear cell types
 class ContourMarchingCells
 {
@@ -87,22 +123,18 @@ public:
   //----------------------------------------------------------------------------
   void ReleaseCellMapArrays() { this->SharedState.CellIdMap.ReleaseResources(); }
 
+public:
   // Filter called without normals generation
-  template <typename ValueType,
+  template <typename ValueType, typename StorageTagField>
-            typename CellSetType,
+  VTKM_CONT vtkm::cont::CellSetSingleType<> Run(
-            typename CoordinateSystem,
-            typename StorageTagField,
-            typename CoordinateType,
-            typename StorageTagVertices>
-  vtkm::cont::CellSetSingleType<> Run(
     const std::vector<ValueType>& isovalues,
-    const CellSetType& cells,
+    const vtkm::cont::UnknownCellSet& cells,
-    const CoordinateSystem& coordinateSystem,
+    const vtkm::cont::CoordinateSystem& coordinateSystem,
     const vtkm::cont::ArrayHandle<ValueType, StorageTagField>& input,
-    vtkm::cont::ArrayHandle<vtkm::Vec<CoordinateType, 3>, StorageTagVertices>& vertices)
+    vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices)
   {
     this->SharedState.GenerateNormals = false;
-    vtkm::cont::ArrayHandle<vtkm::Vec<CoordinateType, 3>> normals;
+    vtkm::cont::ArrayHandle<vtkm::Vec3f> normals;
 
     vtkm::cont::CellSetSingleType<> outputCells;
     vtkm::cont::CastAndCall(cells,
@@ -118,20 +150,14 @@ public:
   }
 
   // Filter called with normals generation
-  template <typename ValueType,
+  template <typename ValueType, typename StorageTagField>
-            typename CellSetType,
+  VTKM_CONT vtkm::cont::CellSetSingleType<> Run(
-            typename CoordinateSystem,
-            typename StorageTagField,
-            typename CoordinateType,
-            typename StorageTagVertices,
-            typename StorageTagNormals>
-  vtkm::cont::CellSetSingleType<> Run(
     const std::vector<ValueType>& isovalues,
-    const CellSetType& cells,
+    const vtkm::cont::UnknownCellSet& cells,
-    const CoordinateSystem& coordinateSystem,
+    const vtkm::cont::CoordinateSystem& coordinateSystem,
     const vtkm::cont::ArrayHandle<ValueType, StorageTagField>& input,
-    vtkm::cont::ArrayHandle<vtkm::Vec<CoordinateType, 3>, StorageTagVertices>& vertices,
+    vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
-    vtkm::cont::ArrayHandle<vtkm::Vec<CoordinateType, 3>, StorageTagNormals>& normals)
+    vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals)
   {
     this->SharedState.GenerateNormals = true;
 
@@ -152,7 +178,100 @@ public:
 private:
   vtkm::worklet::contour::CommonState SharedState;
 };
+
 }
 } // namespace vtkm::worklet
 
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetStructured<2>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float32>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetStructured<2>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float64>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetStructured<3>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float32>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetStructured<3>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float64>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetExplicit<>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float32>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetExplicit<>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float64>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetSingleType<>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float32>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+VTKM_INSTANTIATION_BEGIN
+extern template void vtkm::worklet::contour::DeduceCellType::operator()(
+  const vtkm::cont::CellSetSingleType<>& cells,
+  const vtkm::cont::CoordinateSystem& coordinateSystem,
+  vtkm::cont::CellSetSingleType<>& outputCells,
+  const std::vector<vtkm::Float64>& isovalues,
+  const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagBasic>& input,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& vertices,
+  vtkm::cont::ArrayHandle<vtkm::Vec3f>& normals,
+  vtkm::worklet::contour::CommonState& sharedState) const;
+VTKM_INSTANTIATION_END
+
 #endif // vtk_m_worklet_ContourMarchingCells_h