Buffer.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_vtkm_cont_internal_Buffer_h
#define vtk_m_vtkm_cont_internal_Buffer_h
 
#include <vtkm/cont/vtkm_cont_export.h>
 
#include <vtkm/cont/DeviceAdapterTag.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/cont/Token.h>
 
#include <vtkm/cont/internal/DeviceAdapterMemoryManager.h>
 
#include <memory>
#include <mutex>
 
namespace vtkm
{
 
namespace internal
{
 
VTKM_CONT_EXPORT vtkm::BufferSizeType NumberOfValuesToNumberOfBytes(vtkm::Id numValues,
                                                                    std::size_t typeSize);
 
template <typename T>
vtkm::BufferSizeType NumberOfValuesToNumberOfBytes(vtkm::Id numValues)
{
  return NumberOfValuesToNumberOfBytes(numValues, sizeof(T));
}
 
} // namespace internal
 
namespace cont
{
namespace internal
{
 
namespace detail
{
 
struct BufferHelper;
 
using DeleterType = void(void*);
 
template <typename T>
void BasicDeleter(void* mem)
{
  T* obj = reinterpret_cast<T*>(mem);
  delete obj;
}
 
using CopierType = void*(const void*);
template <typename T>
void* BasicCopier(const void* mem)
{
  return new T(*reinterpret_cast<const T*>(mem));
}
 
} // namespace detail
 
class VTKM_CONT_EXPORT Buffer final
{
  class InternalsStruct;
  std::shared_ptr<InternalsStruct> Internals;
 
  friend struct vtkm::cont::internal::detail::BufferHelper;
 
public:
  VTKM_CONT Buffer();
 
  VTKM_CONT Buffer(const Buffer& src);
  VTKM_CONT Buffer(Buffer&& src) noexcept;
 
  VTKM_CONT ~Buffer();
 
  VTKM_CONT Buffer& operator=(const Buffer& src);
  VTKM_CONT Buffer& operator=(Buffer&& src) noexcept;
 
  VTKM_CONT vtkm::BufferSizeType GetNumberOfBytes() const;
 
  VTKM_CONT void SetNumberOfBytes(vtkm::BufferSizeType numberOfBytes,
                                  vtkm::CopyFlag preserve,
                                  vtkm::cont::Token& token) const;
 
private:
  VTKM_CONT bool MetaDataIsType(const std::string& type) const;
  VTKM_CONT void SetMetaData(void* data,
                             const std::string& type,
                             detail::DeleterType* deleter,
                             detail::CopierType copier) const;
  VTKM_CONT void* GetMetaData(const std::string& type) const;
 
public:
  VTKM_CONT bool HasMetaData() const;
 
  template <typename MetaDataType>
  VTKM_CONT bool MetaDataIsType() const
  {
    return this->MetaDataIsType(vtkm::cont::TypeToString<MetaDataType>());
  }
 
  template <typename MetaDataType>
  VTKM_CONT void SetMetaData(const MetaDataType& metadata) const
  {
    MetaDataType* metadataCopy = new MetaDataType(metadata);
    this->SetMetaData(metadataCopy,
                      vtkm::cont::TypeToString(metadata),
                      detail::BasicDeleter<MetaDataType>,
                      detail::BasicCopier<MetaDataType>);
  }
 
  template <typename MetaDataType>
  VTKM_CONT MetaDataType& GetMetaData() const
  {
    if (!this->HasMetaData())
    {
      this->SetMetaData(MetaDataType{});
    }
    return *reinterpret_cast<MetaDataType*>(
      this->GetMetaData(vtkm::cont::TypeToString<MetaDataType>()));
  }
 
  VTKM_CONT bool IsAllocatedOnHost() const;
 
  VTKM_CONT bool IsAllocatedOnDevice(vtkm::cont::DeviceAdapterId device) const;
 
  VTKM_CONT const void* ReadPointerHost(vtkm::cont::Token& token) const;
 
  VTKM_CONT const void* ReadPointerDevice(vtkm::cont::DeviceAdapterId device,
                                          vtkm::cont::Token& token) const;
 
  VTKM_CONT void* WritePointerHost(vtkm::cont::Token& token) const;
 
  VTKM_CONT void* WritePointerDevice(vtkm::cont::DeviceAdapterId device,
                                     vtkm::cont::Token& token) const;
 
  VTKM_CONT void Enqueue(const vtkm::cont::Token& token) const;
 
  VTKM_CONT void DeepCopyFrom(const vtkm::cont::internal::Buffer& source) const;
  VTKM_CONT void DeepCopyFrom(const vtkm::cont::internal::Buffer& source,
                              vtkm::cont::DeviceAdapterId device) const;
 
  VTKM_CONT void Reset(const vtkm::cont::internal::BufferInfo& buffer);
 
  VTKM_CONT void ReleaseDeviceResources() const;
 
  VTKM_CONT vtkm::cont::internal::BufferInfo GetHostBufferInfo() const;
 
  VTKM_CONT vtkm::cont::internal::BufferInfo GetDeviceBufferInfo(
    vtkm::cont::DeviceAdapterId device) const;
 
  VTKM_CONT vtkm::cont::internal::TransferredBuffer TakeHostBufferOwnership() const;
 
  VTKM_CONT vtkm::cont::internal::TransferredBuffer TakeDeviceBufferOwnership(
    vtkm::cont::DeviceAdapterId device) const;
 
  VTKM_CONT void Fill(const void* source,
                      vtkm::BufferSizeType sourceSize,
                      vtkm::BufferSizeType start,
                      vtkm::BufferSizeType end,
                      vtkm::cont::Token& token) const;
 
  VTKM_CONT bool operator==(const vtkm::cont::internal::Buffer& rhs) const
  {
    return (this->Internals == rhs.Internals);
  }
 
  VTKM_CONT bool operator!=(const vtkm::cont::internal::Buffer& rhs) const
  {
    return (this->Internals != rhs.Internals);
  }
};
 
template <typename... ResetArgs>
VTKM_CONT vtkm::cont::internal::Buffer MakeBuffer(ResetArgs&&... resetArgs)
{
  vtkm::cont::internal::Buffer buffer;
  buffer.Reset(vtkm::cont::internal::BufferInfo(std::forward<ResetArgs>(resetArgs)...));
  return buffer;
}
}
}
} // namespace vtkm::cont::internal
 
//=============================================================================
// Specializations of serialization related classes
namespace mangled_diy_namespace
{
 
template <>
struct VTKM_CONT_EXPORT Serialization<vtkm::cont::internal::Buffer>
{
  static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::internal::Buffer& obj);
  static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::internal::Buffer& obj);
};
 
} // diy
 
#endif //vtk_m_vtkm_cont_internal_Buffer_h