TryExecute.h

Go to the documentation of this file.

//============================================================================
//  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.
//============================================================================
#ifndef vtk_m_cont_TryExecute_h
#define vtk_m_cont_TryExecute_h
 
#include <vtkm/cont/DeviceAdapterList.h>
#include <vtkm/cont/DeviceAdapterTag.h>
#include <vtkm/cont/ErrorUserAbort.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
 
 
namespace vtkm
{
namespace cont
{
 
namespace detail
{
 
VTKM_CONT_EXPORT void HandleTryExecuteException(vtkm::cont::DeviceAdapterId,
                                                vtkm::cont::RuntimeDeviceTracker&,
                                                const std::string& functorName);
 
template <typename DeviceTag, typename Functor, typename... Args>
inline bool TryExecuteIfValid(std::true_type,
                              DeviceTag tag,
                              Functor&& f,
                              vtkm::cont::DeviceAdapterId devId,
                              vtkm::cont::RuntimeDeviceTracker& tracker,
                              Args&&... args)
{
  if ((tag == devId || devId == DeviceAdapterTagAny()) && tracker.CanRunOn(tag))
  {
    try
    {
      if (tracker.CheckForAbortRequest())
      {
        throw vtkm::cont::ErrorUserAbort{};
      }
 
      return f(tag, std::forward<Args>(args)...);
    }
    catch (...)
    {
      detail::HandleTryExecuteException(tag, tracker, vtkm::cont::TypeToString<Functor>());
    }
  }
 
  // If we are here, then the functor was either never run or failed.
  return false;
}
 
template <typename DeviceTag, typename Functor, typename... Args>
inline bool TryExecuteIfValid(std::false_type,
                              DeviceTag,
                              Functor&&,
                              vtkm::cont::DeviceAdapterId,
                              vtkm::cont::RuntimeDeviceTracker&,
                              Args&&...)
{
  return false;
}
 
struct TryExecuteWrapper
{
  template <typename DeviceTag, typename Functor, typename... Args>
  inline void operator()(DeviceTag tag,
                         Functor&& f,
                         vtkm::cont::DeviceAdapterId devId,
                         vtkm::cont::RuntimeDeviceTracker& tracker,
                         bool& ran,
                         Args&&... args) const
  {
    if (!ran)
    {
      ran = TryExecuteIfValid(std::integral_constant<bool, DeviceTag::IsEnabled>(),
                              tag,
                              std::forward<Functor>(f),
                              devId,
                              std::forward<decltype(tracker)>(tracker),
                              std::forward<Args>(args)...);
    }
  }
};
 
template <typename Functor, typename DeviceList, typename... Args>
inline bool TryExecuteImpl(vtkm::cont::DeviceAdapterId devId,
                           Functor&& functor,
                           std::true_type,
                           DeviceList list,
                           Args&&... args)
{
  bool success = false;
  auto& tracker = vtkm::cont::GetRuntimeDeviceTracker();
  TryExecuteWrapper task;
  vtkm::ListForEach(task,
                    list,
                    std::forward<Functor>(functor),
                    devId,
                    tracker,
                    success,
                    std::forward<Args>(args)...);
  return success;
}
 
template <typename Functor, typename... Args>
inline bool TryExecuteImpl(vtkm::cont::DeviceAdapterId devId,
                           Functor&& functor,
                           std::false_type,
                           Args&&... args)
{
  bool success = false;
  auto& tracker = vtkm::cont::GetRuntimeDeviceTracker();
  TryExecuteWrapper task;
  vtkm::ListForEach(task,
                    VTKM_DEFAULT_DEVICE_ADAPTER_LIST(),
                    std::forward<Functor>(functor),
                    devId,
                    tracker,
                    success,
                    std::forward<Args>(args)...);
  return success;
}
} // namespace detail
 
template <typename Functor>
VTKM_CONT bool TryExecuteOnDevice(vtkm::cont::DeviceAdapterId devId, Functor&& functor)
{
  //we haven't been passed either a runtime tracker or a device list
  return detail::TryExecuteImpl(devId, std::forward<Functor>(functor), std::false_type{});
}
template <typename Functor, typename Arg1, typename... Args>
VTKM_CONT bool TryExecuteOnDevice(vtkm::cont::DeviceAdapterId devId,
                                  Functor&& functor,
                                  Arg1&& arg1,
                                  Args&&... args)
{
  //determine if we are being passed a device adapter or runtime tracker as our argument
  using is_deviceAdapter = vtkm::internal::IsList<Arg1>;
 
  return detail::TryExecuteImpl(devId,
                                std::forward<Functor>(functor),
                                is_deviceAdapter{},
                                std::forward<Arg1>(arg1),
                                std::forward<Args>(args)...);
}
 
 
template <typename Functor, typename... Args>
VTKM_CONT bool TryExecute(Functor&& functor, Args&&... args)
{
  return TryExecuteOnDevice(
    vtkm::cont::DeviceAdapterTagAny(), std::forward<Functor>(functor), std::forward<Args>(args)...);
}
 
 
}
} // namespace vtkm::cont
 
#endif //vtk_m_cont_TryExecute_h