ArrayHandleExecutionManager.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_exec_ArrayHandleExecutionManager_h
#define vtk_m_cont_exec_ArrayHandleExecutionManager_h
 
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/Token.h>
 
#include <vtkm/cont/internal/ArrayTransfer.h>
 
namespace vtkm
{
namespace cont
{
namespace internal
{
 
template <typename T, typename Storage>
class ArrayHandleExecutionManagerBase
{
private:
  using StorageType = vtkm::cont::internal::Storage<T, Storage>;
 
public:
  template <typename DeviceAdapter>
  struct ExecutionTypes
  {
  private:
    using ArrayTransferType = vtkm::cont::internal::ArrayTransfer<T, Storage, DeviceAdapter>;
 
  public:
    using Portal = typename ArrayTransferType::PortalExecution;
    using PortalConst = typename ArrayTransferType::PortalConstExecution;
  };
 
  using ValueType = T;
 
  using PortalControl = typename StorageType::PortalType;
  using PortalConstControl = typename StorageType::PortalConstType;
 
  VTKM_CONT
  virtual ~ArrayHandleExecutionManagerBase() {}
 
  VTKM_CONT
  vtkm::Id GetNumberOfValues() const { return this->GetNumberOfValuesImpl(); }
 
  template <typename DeviceAdapter>
  VTKM_CONT typename ExecutionTypes<DeviceAdapter>::PortalConst
  PrepareForInput(bool updateData, DeviceAdapter, vtkm::cont::Token& token)
  {
    this->VerifyDeviceAdapter(DeviceAdapter());
 
    typename ExecutionTypes<DeviceAdapter>::PortalConst portal;
    this->PrepareForInputImpl(updateData, &portal, token);
    return portal;
  }
 
  template <typename DeviceAdapter>
  VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal
  PrepareForInPlace(bool updateData, DeviceAdapter, vtkm::cont::Token& token)
  {
    this->VerifyDeviceAdapter(DeviceAdapter());
 
    typename ExecutionTypes<DeviceAdapter>::Portal portal;
    this->PrepareForInPlaceImpl(updateData, &portal, token);
    return portal;
  }
 
  template <typename DeviceAdapter>
  VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal
  PrepareForOutput(vtkm::Id numberOfValues, DeviceAdapter, vtkm::cont::Token& token)
  {
    this->VerifyDeviceAdapter(DeviceAdapter());
 
    typename ExecutionTypes<DeviceAdapter>::Portal portal;
    this->PrepareForOutputImpl(numberOfValues, &portal, token);
    return portal;
  }
 
  VTKM_CONT
  void RetrieveOutputData(StorageType* storage) const { this->RetrieveOutputDataImpl(storage); }
 
  VTKM_CONT
  void Shrink(vtkm::Id numberOfValues) { this->ShrinkImpl(numberOfValues); }
 
  VTKM_CONT
  void ReleaseResources() { this->ReleaseResourcesImpl(); }
 
  template <typename DeviceAdapter>
  VTKM_CONT bool IsDeviceAdapter(DeviceAdapter device) const
  {
    return this->IsDeviceAdapterImpl(device);
  }
 
  VTKM_CONT
  DeviceAdapterId GetDeviceAdapterId() const { return this->GetDeviceAdapterIdImpl(); }
 
protected:
  virtual vtkm::Id GetNumberOfValuesImpl() const = 0;
 
  virtual void PrepareForInputImpl(bool updateData,
                                   void* portalExecutionVoid,
                                   vtkm::cont::Token& token) = 0;
 
  virtual void PrepareForInPlaceImpl(bool updateData,
                                     void* portalExecutionVoid,
                                     vtkm::cont::Token& token) = 0;
 
  virtual void PrepareForOutputImpl(vtkm::Id numberOfValues,
                                    void* portalExecution,
                                    vtkm::cont::Token& token) = 0;
 
  virtual void RetrieveOutputDataImpl(StorageType* storage) const = 0;
 
  virtual void ShrinkImpl(Id numberOfValues) = 0;
 
  virtual void ReleaseResourcesImpl() = 0;
 
  virtual bool IsDeviceAdapterImpl(const vtkm::cont::DeviceAdapterId& id) const = 0;
 
  virtual DeviceAdapterId GetDeviceAdapterIdImpl() const = 0;
 
private:
  template <typename DeviceAdapter>
  VTKM_CONT void VerifyDeviceAdapter(DeviceAdapter device) const
  {
    if (!this->IsDeviceAdapter(device))
    {
      throw vtkm::cont::ErrorInternal("Device Adapter Mismatch");
    }
  }
};
 
template <typename T, typename Storage, typename DeviceAdapter>
class ArrayHandleExecutionManager : public ArrayHandleExecutionManagerBase<T, Storage>
{
  using Superclass = ArrayHandleExecutionManagerBase<T, Storage>;
  using ArrayTransferType = vtkm::cont::internal::ArrayTransfer<T, Storage, DeviceAdapter>;
  using StorageType = vtkm::cont::internal::Storage<T, Storage>;
 
public:
  using PortalControl = typename ArrayTransferType::PortalControl;
  using PortalConstControl = typename ArrayTransferType::PortalConstControl;
 
  using PortalExecution = typename ArrayTransferType::PortalExecution;
  using PortalConstExecution = typename ArrayTransferType::PortalConstExecution;
 
  VTKM_CONT
  ArrayHandleExecutionManager(StorageType* storage)
    : Transfer(storage)
  {
  }
 
protected:
  VTKM_CONT
  vtkm::Id GetNumberOfValuesImpl() const { return this->Transfer.GetNumberOfValues(); }
 
  VTKM_CONT
  void PrepareForInputImpl(bool updateData, void* portalExecutionVoid, vtkm::cont::Token& token)
  {
    PortalConstExecution portal = this->Transfer.PrepareForInput(updateData, token);
    *reinterpret_cast<PortalConstExecution*>(portalExecutionVoid) = portal;
  }
 
  VTKM_CONT
  void PrepareForInPlaceImpl(bool updateData, void* portalExecutionVoid, vtkm::cont::Token& token)
  {
    PortalExecution portal = this->Transfer.PrepareForInPlace(updateData, token);
    *reinterpret_cast<PortalExecution*>(portalExecutionVoid) = portal;
  }
 
  VTKM_CONT
  void PrepareForOutputImpl(vtkm::Id numberOfValues,
                            void* portalExecutionVoid,
                            vtkm::cont::Token& token)
  {
    PortalExecution portal = this->Transfer.PrepareForOutput(numberOfValues, token);
    *reinterpret_cast<PortalExecution*>(portalExecutionVoid) = portal;
  }
 
  VTKM_CONT
  void RetrieveOutputDataImpl(StorageType* storage) const
  {
    this->Transfer.RetrieveOutputData(storage);
  }
 
  VTKM_CONT
  void ShrinkImpl(Id numberOfValues) { this->Transfer.Shrink(numberOfValues); }
 
  VTKM_CONT
  void ReleaseResourcesImpl() { this->Transfer.ReleaseResources(); }
 
  VTKM_CONT
  bool IsDeviceAdapterImpl(const DeviceAdapterId& id) const { return id == DeviceAdapter(); }
 
  VTKM_CONT
  DeviceAdapterId GetDeviceAdapterIdImpl() const { return DeviceAdapter(); }
 
private:
  ArrayTransferType Transfer;
};
}
}
} // namespace vtkm::cont::internal
 
#endif //vtk_m_cont_exec_ArrayHandleExecutionManager_h