Add initial version of an OpenMP backend.

CMake/VTKmConfig.cmake.in

@@ -27,6 +27,9 @@
 #   vtkm::tbb       Target that contains tbb related link information
 #                   implicitly linked to by `vtkm_cont` if tbb is enabled
 #
+#   vtkm::openmp    Target that contains openmp related link information
+#                   implicitly linked to by `vtkm_cont` if openmp is enabled
+#
 #   vtkm::cuda      Target that contains cuda related link information
 #                   implicitly linked to by `vtkm_cont` if cuda is enabled
 #
@@ -41,6 +44,7 @@
 #  VTKm_BUILD_SHARED_LIBS     Will be enabled if VTK-m was built shared/dynamic
 #  VTKm_ENABLE_CUDA           Will be enabled if VTK-m was built with CUDA support
 #  VTKm_ENABLE_TBB            Will be enabled if VTK-m was built with TBB support
+#  VTKm_ENABLE_OPENMP         Will be enabled if VTK-m was built with OpenMP support
 #  VTKm_ENABLE_MPI            Will be enabled if VTK-m was built with MPI support
 #  VTKm_ENABLE_RENDERING      Will be enabled if VTK-m was built with rendering support
 #  VTKm_ENABLE_GL_CONTEXT     Will be enabled if VTK-m rendering was built with a GL context
@@ -63,6 +67,7 @@ set(VTKm_VERSION "@VTKm_VERSION@")
 set(VTKm_BUILD_SHARED_LIBS "@VTKm_BUILD_SHARED_LIBS@")
 set(VTKm_ENABLE_CUDA "@VTKm_ENABLE_CUDA@")
 set(VTKm_ENABLE_TBB "@VTKm_ENABLE_TBB@")
+set(VTKm_ENABLE_OPENMP "@VTKm_ENABLE_OPENMP@")
 set(VTKm_ENABLE_RENDERING "@VTKm_ENABLE_RENDERING@")
 set(VTKm_ENABLE_GL_CONTEXT "@VTKm_ENABLE_GL_CONTEXT@")
 set(VTKm_ENABLE_OSMESA_CONTEXT "@VTKm_ENABLE_OSMESA_CONTEXT@")

CMake/VTKmDeviceAdapters.cmake

@@ -47,6 +47,19 @@ if(VTKm_ENABLE_TBB AND NOT TARGET vtkm::tbb)
     endif()
 endif()
 
+if(VTKm_ENABLE_OPENMP AND NOT TARGET vtkm::openmp)
+  find_package(OpenMP 4.5 REQUIRED COMPONENTS CXX QUIET)
+
+  add_library(vtkm::openmp INTERFACE IMPORTED GLOBAL)
+  if(OpenMP_CXX_FLAGS)
+    set_target_properties(vtkm::openmp PROPERTIES
+      INTERFACE_COMPILE_OPTIONS "$<$<COMPILE_LANGUAGE:CXX>:${OpenMP_CXX_FLAGS}>")
+  endif()
+  if(OpenMP_CXX_LIBRARIES)
+    set_target_properties(vtkm::openmp PROPERTIES
+      INTERFACE_LINK_LIBRARIES "${OpenMP_CXX_LIBRARIES}")
+  endif()
+endif()
 
 if(VTKm_ENABLE_CUDA AND NOT TARGET vtkm::cuda)
   cmake_minimum_required(VERSION 3.9 FATAL_ERROR)

CMakeLists.txt

@@ -86,6 +86,7 @@ endmacro ()
 # Configurable Options
 vtkm_option(VTKm_ENABLE_CUDA "Enable Cuda support" OFF)
 vtkm_option(VTKm_ENABLE_TBB "Enable TBB support" OFF)
+vtkm_option(VTKm_ENABLE_OPENMP "Enable OpenMP support" OFF)
 vtkm_option(VTKm_ENABLE_RENDERING "Enable rendering library" ON)
 vtkm_option(VTKm_ENABLE_TESTING "Enable VTKm Testing" ON)
 vtkm_option(VTKm_ENABLE_BENCHMARKS "Enable VTKm Benchmarking" OFF)
@@ -266,6 +267,7 @@ if(NOT VTKm_INSTALL_ONLY_LIBRARIES)
     FILES
       ${VTKm_SOURCE_DIR}/CMake/FindTBB.cmake
       ${VTKm_SOURCE_DIR}/CMake/FindOpenGL.cmake
+      ${VTKm_SOURCE_DIR}/CMake/FindOpenMP.cmake
     DESTINATION ${VTKm_INSTALL_CMAKE_MODULE_DIR}
     )
 

README.md

@@ -73,6 +73,8 @@ Optional dependencies are:
       + [Cuda Toolkit 7+](https://developer.nvidia.com/cuda-toolkit)
   + TBB Device Adapter
       + [TBB](https://www.threadingbuildingblocks.org/)
+  + OpenMP Device Adapter
+      + Requires a compiler that supports OpenMP >= 4.5.
   + OpenGL Rendering
       + The rendering module contains multiple rendering implementations
         including standalone rendering code. The rendering module also

benchmarking/BenchmarkDeviceAdapter.cxx

@@ -46,7 +46,9 @@
 
 #if VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_TBB
 #include <tbb/task_scheduler_init.h>
-#endif // TBB
+#elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+#include <omp.h>
+#endif
 
 // This benchmark has a number of commandline options to customize its behavior.
 // See The BenchDevAlgoConfig documentations for details.
@@ -1193,6 +1195,8 @@ int main(int argc, char* argv[])
 {
 #if VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_TBB
   int numThreads = tbb::task_scheduler_init::automatic;
+#elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+  int numThreads = omp_get_max_threads();
 #endif // TBB
 
   vtkm::benchmarking::BenchDevAlgoConfig& config = vtkm::benchmarking::Config;
@@ -1323,8 +1327,12 @@ int main(int argc, char* argv[])
       std::istringstream parse(argv[i]);
       parse >> numThreads;
       std::cout << "Selected " << numThreads << " TBB threads." << std::endl;
+#elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+      std::istringstream parse(argv[i]);
+      parse >> numThreads;
+      std::cout << "Selected " << numThreads << " OpenMP threads." << std::endl;
 #else
-      std::cerr << "NumThreads valid only on TBB. Ignoring." << std::endl;
+      std::cerr << "NumThreads not valid on this device. Ignoring." << std::endl;
 #endif // TBB
     }
     else
@@ -1337,6 +1345,8 @@ int main(int argc, char* argv[])
 #if VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_TBB
   // Must not be destroyed as long as benchmarks are running:
   tbb::task_scheduler_init init(numThreads);
+#elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+  omp_set_num_threads(numThreads);
 #endif // TBB
 
   if (config.BenchmarkFlags == 0)

benchmarking/CMakeLists.txt

@@ -30,6 +30,12 @@ function(add_benchmark name files)
     target_compile_definitions(${name}_TBB PRIVATE "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_TBB")
   endif()
 
+  if (TARGET vtkm::openmp)
+    add_executable(${name}_OPENMP ${files})
+    list(APPEND benchmarks ${name}_OPENMP)
+    target_compile_definitions(${name}_OPENMP PRIVATE "VTKM_DEVICE_ADAPTER=VTKM_DEVICE_ADAPTER_OPENMP")
+  endif()
+
   if (TARGET vtkm::cuda)
     get_filename_component(fname "${name}" NAME_WE)
     get_filename_component(fullpath "${name}.cxx" ABSOLUTE)
@@ -70,6 +76,9 @@ if(TARGET vtkm_rendering)
   if(TARGET BenchmarkRayTracing_TBB)
     target_link_libraries(BenchmarkRayTracing_TBB PRIVATE vtkm_rendering)
   endif()
+  if(TARGET BenchmarkRayTracing_OPENMP)
+    target_link_libraries(BenchmarkRayTracing_OPENMP PRIVATE vtkm_rendering)
+  endif()
   if(TARGET BenchmarkRayTracing_CUDA)
     target_link_libraries(BenchmarkRayTracing_CUDA PRIVATE vtkm_rendering)
   endif()

docs/changelog/openmp-backend.md

+# OpenMP Device Adapter
+
+A device adapter that leverages OpenMP 4.5 for threading is now available. The
+new adapter is enabled using the CMake option `VTKm_ENABLE_OPENMP` and its
+performance is comparable to the TBB device adapter.

vtkm/cont/CMakeLists.txt

@@ -151,6 +151,7 @@ add_subdirectory(arg)
 add_subdirectory(diy)
 add_subdirectory(serial)
 add_subdirectory(tbb)
+add_subdirectory(openmp)
 add_subdirectory(cuda)
 
 set(backends )
@@ -160,6 +161,9 @@ endif()
 if(TARGET vtkm::cuda)
   list(APPEND backends vtkm::cuda)
 endif()
+if(TARGET vtkm::openmp)
+  list(APPEND backends vtkm::openmp)
+endif()
 target_link_libraries(vtkm_cont PUBLIC vtkm_compiler_flags ${backends})
 if(TARGET vtkm_diy)
   # This will become a required dependency eventually.

vtkm/cont/DeviceAdapterListTag.h

@@ -27,6 +27,7 @@
 #include <vtkm/ListTag.h>
 
 #include <vtkm/cont/cuda/DeviceAdapterCuda.h>
+#include <vtkm/cont/openmp/DeviceAdapterOpenMP.h>
 #include <vtkm/cont/serial/DeviceAdapterSerial.h>
 #include <vtkm/cont/tbb/DeviceAdapterTBB.h>
 
@@ -37,6 +38,7 @@ namespace cont
 
 struct DeviceAdapterListTagCommon : vtkm::ListTagBase<vtkm::cont::DeviceAdapterTagCuda,
                                                       vtkm::cont::DeviceAdapterTagTBB,
+                                                      vtkm::cont::DeviceAdapterTagOpenMP,
                                                       vtkm::cont::DeviceAdapterTagSerial>
 {
 };

vtkm/cont/internal/DeviceAdapterDefaultSelection.h

@@ -36,7 +36,9 @@
 // Unfortunately, VTKM_ENABLE_TBB does not guarantee that TBB is (or isn't)
 // available, but there is no way to check for sure in a header library.
 #define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_TBB
-#else // !VTKM_CUDA && !VTKM_ENABLE_TBB
+#elif defined(VTKM_ENABLE_OPENMP)
+#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_OPENMP
+#else // !VTKM_CUDA && !VTKM_ENABLE_TBB && !VTKM_ENABLE_OPENMP
 #define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
 #endif // !VTKM_CUDA && !VTKM_ENABLE_TBB
 #endif // VTKM_DEVICE_ADAPTER
@@ -68,6 +70,14 @@
 #include <vtkm/cont/tbb/internal/DeviceAdapterTagTBB.h>
 #define VTKM_DEFAULT_DEVICE_ADAPTER_TAG ::vtkm::cont::DeviceAdapterTagTBB
 
+// OpenMP:
+#elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_OPENMP
+
+#include <vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.h>
+#include <vtkm/cont/openmp/internal/DeviceAdapterAlgorithmOpenMP.h>
+#include <vtkm/cont/openmp/internal/DeviceAdapterTagOpenMP.h>
+#define VTKM_DEFAULT_DEVICE_ADAPTER_TAG ::vtkm::cont::DeviceAdapterTagOpenMP
+
 // Error:
 #elif VTKM_DEVICE_ADAPTER == VTKM_DEVICE_ADAPTER_ERROR
 

vtkm/cont/internal/DeviceAdapterTag.h

@@ -32,6 +32,7 @@
 #define VTKM_DEVICE_ADAPTER_SERIAL 1
 #define VTKM_DEVICE_ADAPTER_CUDA 2
 #define VTKM_DEVICE_ADAPTER_TBB 3
+#define VTKM_DEVICE_ADAPTER_OPENMP 4
 
 namespace vtkm
 {

vtkm/cont/openmp/CMakeLists.txt

+##============================================================================
+##  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+##  Copyright 2018 UT-Battelle, LLC.
+##  Copyright 2018 Los Alamos National Security.
+##
+##  Under the terms of Contract DE-NA0003525 with NTESS,
+##  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
+  DeviceAdapterOpenMP.h
+  )
+
+add_subdirectory(internal)
+
+vtkm_declare_headers(${headers} TESTABLE ${VTKm_ENABLE_OPENMP})
+
+#-----------------------------------------------------------------------------
+if (TARGET vtkm::openmp)
+  add_subdirectory(testing)
+endif()

vtkm/cont/openmp/DeviceAdapterOpenMP.h

+//============================================================================
+//  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2018 UT-Battelle, LLC.
+//  Copyright 2018 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#ifndef vtk_m_cont_openmp_DeviceAdapterOpenMP_h
+#define vtk_m_cont_openmp_DeviceAdapterOpenMP_h
+
+#include <vtkm/cont/openmp/internal/DeviceAdapterRuntimeDetectorOpenMP.h>
+#include <vtkm/cont/openmp/internal/DeviceAdapterTagOpenMP.h>
+
+#ifdef VTKM_ENABLE_OPENMP
+#include <vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.h>
+#include <vtkm/cont/openmp/internal/DeviceAdapterAlgorithmOpenMP.h>
+#include <vtkm/cont/openmp/internal/VirtualObjectTransferOpenMP.h>
+#endif
+
+#endif //vtk_m_cont_openmp_DeviceAdapterOpenMP_h

vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.cxx

+//============================================================================
+//  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2018 UT-Battelle, LLC.
+//  Copyright 2018 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#define vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_cxx
+
+#include <vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.h>
+
+namespace vtkm
+{
+namespace cont
+{
+namespace internal
+{
+
+ExecutionArrayInterfaceBasic<DeviceAdapterTagOpenMP>::ExecutionArrayInterfaceBasic(
+  StorageBasicBase& storage)
+  : Superclass(storage)
+{
+}
+
+} // end namespace internal
+
+VTKM_INSTANTIATE_ARRAYHANDLES_FOR_DEVICE_ADAPTER(DeviceAdapterTagOpenMP)
+}
+} // end vtkm::cont

vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.h

+//============================================================================
+//  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2018 UT-Battelle, LLC.
+//  Copyright 2018 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#ifndef vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_h
+#define vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_h
+
+
+#include <vtkm/cont/openmp/internal/DeviceAdapterTagOpenMP.h>
+
+#include <vtkm/cont/internal/ArrayExportMacros.h>
+#include <vtkm/cont/internal/ArrayManagerExecution.h>
+#include <vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h>
+
+namespace vtkm
+{
+namespace cont
+{
+namespace internal
+{
+
+template <typename T, class StorageTag>
+class ArrayManagerExecution<T, StorageTag, vtkm::cont::DeviceAdapterTagOpenMP>
+  : public vtkm::cont::internal::ArrayManagerExecutionShareWithControl<T, StorageTag>
+{
+public:
+  using Superclass = vtkm::cont::internal::ArrayManagerExecutionShareWithControl<T, StorageTag>;
+  using ValueType = typename Superclass::ValueType;
+  using PortalType = typename Superclass::PortalType;
+  using PortalConstType = typename Superclass::PortalConstType;
+  using StorageType = typename Superclass::StorageType;
+
+  VTKM_CONT
+  ArrayManagerExecution(StorageType* storage)
+    : Superclass(storage)
+  {
+  }
+
+  VTKM_CONT
+  PortalConstType PrepareForInput(bool updateData)
+  {
+    return this->Superclass::PrepareForInput(updateData);
+  }
+
+  VTKM_CONT
+  PortalType PrepareForInPlace(bool updateData)
+  {
+    return this->Superclass::PrepareForInPlace(updateData);
+  }
+
+  VTKM_CONT
+  PortalType PrepareForOutput(vtkm::Id numberOfValues)
+  {
+    return this->Superclass::PrepareForOutput(numberOfValues);
+  }
+};
+
+
+template <typename T>
+struct ExecutionPortalFactoryBasic<T, DeviceAdapterTagOpenMP>
+  : public ExecutionPortalFactoryBasicShareWithControl<T>
+{
+  using Superclass = ExecutionPortalFactoryBasicShareWithControl<T>;
+
+  using typename Superclass::ValueType;
+  using typename Superclass::PortalType;
+  using typename Superclass::PortalConstType;
+  using Superclass::CreatePortal;
+  using Superclass::CreatePortalConst;
+};
+
+template <>
+struct VTKM_CONT_EXPORT ExecutionArrayInterfaceBasic<DeviceAdapterTagOpenMP>
+  : public ExecutionArrayInterfaceBasicShareWithControl
+{
+  using Superclass = ExecutionArrayInterfaceBasicShareWithControl;
+
+  VTKM_CONT
+  ExecutionArrayInterfaceBasic(StorageBasicBase& storage);
+
+  VTKM_CONT
+  DeviceAdapterId GetDeviceId() const final { return VTKM_DEVICE_ADAPTER_OPENMP; }
+};
+
+} // namespace internal
+
+#ifndef vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_cxx
+VTKM_EXPORT_ARRAYHANDLES_FOR_DEVICE_ADAPTER(DeviceAdapterTagOpenMP)
+#endif // !vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_cxx
+}
+} // namespace vtkm::cont
+
+#endif // vtk_m_cont_openmp_internal_ArrayManagerExecutionOpenMP_h

vtkm/cont/openmp/internal/CMakeLists.txt

+##============================================================================
+##  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+##  Copyright 2018 UT-Battelle, LLC.
+##  Copyright 2018 Los Alamos National Security.
+##
+##  Under the terms of Contract DE-NA0003525 with NTESS,
+##  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
+  ArrayManagerExecutionOpenMP.h
+  DeviceAdapterAlgorithmOpenMP.h
+  DeviceAdapterRuntimeDetectorOpenMP.h
+  DeviceAdapterTagOpenMP.h
+  FunctorsOpenMP.h
+  ParallelQuickSortOpenMP.h
+  ParallelRadixSortOpenMP.h
+  ParallelScanOpenMP.h
+  ParallelSortOpenMP.h
+  VirtualObjectTransferOpenMP.h
+  )
+
+vtkm_declare_headers(${headers} TESTABLE ${VTKm_ENABLE_OPENMP})
+
+target_sources(vtkm_cont PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/DeviceAdapterRuntimeDetectorOpenMP.cxx
+  )
+
+#-----------------------------------------------------------------------------
+if (NOT VTKm_ENABLE_OPENMP)
+  return()
+endif()
+
+target_sources(vtkm_cont PRIVATE
+  ${CMAKE_CURRENT_SOURCE_DIR}/ArrayManagerExecutionOpenMP.cxx
+  ${CMAKE_CURRENT_SOURCE_DIR}/DeviceAdapterAlgorithmOpenMP.cxx
+  ${CMAKE_CURRENT_SOURCE_DIR}/ParallelRadixSortOpenMP.cxx
+)

vtkm/cont/openmp/internal/DeviceAdapterAlgorithmOpenMP.cxx

+//============================================================================
+//  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 2018 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+//  Copyright 2018 UT-Battelle, LLC.
+//  Copyright 2018 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-NA0003525 with NTESS,
+//  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.
+//============================================================================
+
+#include <vtkm/cont/openmp/internal/DeviceAdapterAlgorithmOpenMP.h>
+#include <vtkm/cont/openmp/internal/FunctorsOpenMP.h>
+
+#include <vtkm/cont/ErrorExecution.h>
+
+#include <omp.h>
+
+namespace vtkm
+{
+namespace cont
+{
+
+void DeviceAdapterAlgorithm<vtkm::cont::DeviceAdapterTagOpenMP>::ScheduleTask(
+  vtkm::exec::openmp::internal::TaskTiling1D& functor,
+  vtkm::Id size)
+{
+  static constexpr vtkm::Id MESSAGE_SIZE = 1024;
+  char errorString[MESSAGE_SIZE];
+  errorString[0] = '\0';
+  vtkm::exec::internal::ErrorMessageBuffer errorMessage(errorString, MESSAGE_SIZE);
+  functor.SetErrorMessageBuffer(errorMessage);
+
+  static constexpr vtkm::Id CHUNK_SIZE = 1024;
+
+  VTKM_OPENMP_DIRECTIVE(parallel for
+                        schedule(guided))
+  for (vtkm::Id i = 0; i < size; i += CHUNK_SIZE)
+  {
+    const vtkm::Id end = std::min(i + CHUNK_SIZE, size);
+    functor(i, end);
+  }
+
+  if (errorMessage.IsErrorRaised())
+  {
+    throw vtkm::cont::ErrorExecution(errorString);
+  }
+}
+
+void DeviceAdapterAlgorithm<vtkm::cont::DeviceAdapterTagOpenMP>::ScheduleTask(
+  vtkm::exec::openmp::internal::TaskTiling3D& functor,
+  vtkm::Id3 size)
+{
+  static constexpr vtkm::Id MESSAGE_SIZE = 1024;
+  char errorString[MESSAGE_SIZE];
+  errorString[0] = '\0';
+  vtkm::exec::internal::ErrorMessageBuffer errorMessage(errorString, MESSAGE_SIZE);
+  functor.SetErrorMessageBuffer(errorMessage);
+
+  vtkm::Id3 chunkDims;
+  if (size[0] > 512)
+  {
+    chunkDims = { 1024, 4, 1 };
+  }
+  else if (size[0] > 256)
+  {
+    chunkDims = { 512, 4, 2 };
+  }
+  else if (size[0] > 128)
+  {
+    chunkDims = { 256, 4, 4 };
+  }
+  else if (size[0] > 64)
+  {
+    chunkDims = { 128, 8, 4 };
+  }
+  else if (size[0] > 32)
+  {
+    chunkDims = { 64, 8, 8 };
+  }
+  else if (size[0] > 16)
+  {
+    chunkDims = { 32, 16, 8 };
+  }
+  else
+  {
+    chunkDims = { 16, 16, 16 };
+  }
+
+  const vtkm::Id3 numChunks{ openmp::CeilDivide(size[0], chunkDims[0]),
+                             openmp::CeilDivide(size[1], chunkDims[1]),
+                             openmp::CeilDivide(size[2], chunkDims[2]) };
+  const vtkm::Id chunkCount = numChunks[0] * numChunks[1] * numChunks[2];
+
+  // Lambda to convert chunkIdx into a start/end {i, j, k}:
+  auto computeIJK = [&](const vtkm::Id& chunkIdx, vtkm::Id3& start, vtkm::Id3& end) {
+    start[0] = chunkIdx % numChunks[0];
+    start[1] = (chunkIdx / numChunks[0]) % numChunks[1];
+    start[2] = (chunkIdx / (numChunks[0] * numChunks[1]));
+    start *= chunkDims; // c-wise mult
+
+    end[0] = std::min(start[0] + chunkDims[0], size[0]);
+    end[1] = std::min(start[1] + chunkDims[1], size[1]);
+    end[2] = std::min(start[2] + chunkDims[2], size[2]);
+  };
+
+  // Iterate through each chunk, converting the chunkIdx into an ijk range:
+  VTKM_OPENMP_DIRECTIVE(parallel for
+                        schedule(guided))
+  for (vtkm::Id chunkIdx = 0; chunkIdx < chunkCount; ++chunkIdx)
+  {
+    vtkm::Id3 startIJK;
+    vtkm::Id3 endIJK;
+    computeIJK(chunkIdx, startIJK, endIJK);
+
+    for (vtkm::Id k = startIJK[2]; k < endIJK[2]; ++k)