Buffer.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.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.
//============================================================================
#ifndef viskores_viskores_cont_internal_Buffer_h
#define viskores_viskores_cont_internal_Buffer_h
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/cont/DeviceAdapterTag.h>
#include <viskores/cont/Logging.h>
#include <viskores/cont/Serialization.h>
#include <viskores/cont/Token.h>
 
#include <viskores/cont/internal/DeviceAdapterMemoryManager.h>
 
#include <memory>
#include <mutex>
 
namespace viskores
{
 
namespace internal
{
 
VISKORES_CONT_EXPORT viskores::BufferSizeType NumberOfValuesToNumberOfBytes(viskores::Id numValues,
                                                                            std::size_t typeSize);
 
template <typename T>
viskores::BufferSizeType NumberOfValuesToNumberOfBytes(viskores::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 VISKORES_CONT_EXPORT Buffer final
{
  class InternalsStruct;
  std::shared_ptr<InternalsStruct> Internals;
 
  friend struct viskores::cont::internal::detail::BufferHelper;
 
public:
  VISKORES_CONT Buffer();
 
  VISKORES_CONT Buffer(const Buffer& src);
  VISKORES_CONT Buffer(Buffer&& src) noexcept;
 
  VISKORES_CONT ~Buffer();
 
  VISKORES_CONT Buffer& operator=(const Buffer& src);
  VISKORES_CONT Buffer& operator=(Buffer&& src) noexcept;
 
  VISKORES_CONT viskores::BufferSizeType GetNumberOfBytes() const;
 
  VISKORES_CONT void SetNumberOfBytes(viskores::BufferSizeType numberOfBytes,
                                      viskores::CopyFlag preserve,
                                      viskores::cont::Token& token) const;
 
private:
  VISKORES_CONT bool MetaDataIsType(const std::string& type) const;
  VISKORES_CONT void SetMetaData(void* data,
                                 const std::string& type,
                                 detail::DeleterType* deleter,
                                 detail::CopierType copier) const;
  VISKORES_CONT void* GetMetaData(const std::string& type) const;
 
public:
  VISKORES_CONT bool HasMetaData() const;
 
  template <typename MetaDataType>
  VISKORES_CONT bool MetaDataIsType() const
  {
    return this->MetaDataIsType(viskores::cont::TypeToString<MetaDataType>());
  }
 
  template <typename MetaDataType>
  VISKORES_CONT void SetMetaData(const MetaDataType& metadata) const
  {
    MetaDataType* metadataCopy = new MetaDataType(metadata);
    this->SetMetaData(metadataCopy,
                      viskores::cont::TypeToString(metadata),
                      detail::BasicDeleter<MetaDataType>,
                      detail::BasicCopier<MetaDataType>);
  }
 
  template <typename MetaDataType>
  VISKORES_CONT MetaDataType& GetMetaData() const
  {
    if (!this->HasMetaData())
    {
      this->SetMetaData(MetaDataType{});
    }
    return *reinterpret_cast<MetaDataType*>(
      this->GetMetaData(viskores::cont::TypeToString<MetaDataType>()));
  }
 
  VISKORES_CONT bool IsAllocatedOnHost() const;
 
  VISKORES_CONT bool IsAllocatedOnDevice(viskores::cont::DeviceAdapterId device) const;
 
  VISKORES_CONT const void* ReadPointerHost(viskores::cont::Token& token) const;
 
  VISKORES_CONT const void* ReadPointerDevice(viskores::cont::DeviceAdapterId device,
                                              viskores::cont::Token& token) const;
 
  VISKORES_CONT void* WritePointerHost(viskores::cont::Token& token) const;
 
  VISKORES_CONT void* WritePointerDevice(viskores::cont::DeviceAdapterId device,
                                         viskores::cont::Token& token) const;
 
  VISKORES_CONT void Enqueue(const viskores::cont::Token& token) const;
 
  VISKORES_CONT void DeepCopyFrom(const viskores::cont::internal::Buffer& source) const;
  VISKORES_CONT void DeepCopyFrom(const viskores::cont::internal::Buffer& source,
                                  viskores::cont::DeviceAdapterId device) const;
 
  VISKORES_CONT void Reset(const viskores::cont::internal::BufferInfo& buffer);
 
  VISKORES_CONT void ReleaseDeviceResources() const;
 
  VISKORES_CONT viskores::cont::internal::BufferInfo GetHostBufferInfo() const;
 
  VISKORES_CONT viskores::cont::internal::BufferInfo GetDeviceBufferInfo(
    viskores::cont::DeviceAdapterId device) const;
 
  VISKORES_CONT viskores::cont::internal::TransferredBuffer TakeHostBufferOwnership() const;
 
  VISKORES_CONT viskores::cont::internal::TransferredBuffer TakeDeviceBufferOwnership(
    viskores::cont::DeviceAdapterId device) const;
 
  VISKORES_CONT void Fill(const void* source,
                          viskores::BufferSizeType sourceSize,
                          viskores::BufferSizeType start,
                          viskores::BufferSizeType end,
                          viskores::cont::Token& token) const;
 
  VISKORES_CONT bool operator==(const viskores::cont::internal::Buffer& rhs) const
  {
    return (this->Internals == rhs.Internals);
  }
 
  VISKORES_CONT bool operator!=(const viskores::cont::internal::Buffer& rhs) const
  {
    return (this->Internals != rhs.Internals);
  }
};
 
template <typename... ResetArgs>
VISKORES_CONT viskores::cont::internal::Buffer MakeBuffer(ResetArgs&&... resetArgs)
{
  viskores::cont::internal::Buffer buffer;
  buffer.Reset(viskores::cont::internal::BufferInfo(std::forward<ResetArgs>(resetArgs)...));
  return buffer;
}
}
}
} // namespace viskores::cont::internal
 
//=============================================================================
// Specializations of serialization related classes
namespace mangled_diy_namespace
{
 
template <>
struct VISKORES_CONT_EXPORT Serialization<viskores::cont::internal::Buffer>
{
  static VISKORES_CONT void save(BinaryBuffer& bb, const viskores::cont::internal::Buffer& obj);
  static VISKORES_CONT void load(BinaryBuffer& bb, viskores::cont::internal::Buffer& obj);
};
 
} // diy
 
#endif //viskores_viskores_cont_internal_Buffer_h