DeviceAdapterMemoryManager.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_cont_internal_DeviceAdapterMemoryManager_h
#define viskores_cont_internal_DeviceAdapterMemoryManager_h
 
#include <viskores/cont/viskores_cont_export.h>
 
#include <viskores/Flags.h>
#include <viskores/Types.h>
 
#include <viskores/cont/DeviceAdapterTag.h>
 
#include <cstring>
#include <memory>
#include <vector>
 
namespace viskores
{
 
using BufferSizeType = viskores::Int64;
 
namespace cont
{
namespace internal
{
 
struct TransferredBuffer;
 
namespace detail
{
 
struct BufferInfoInternals;
 
} // namespace detail
 
class VISKORES_CONT_EXPORT BufferInfo
{
public:
  VISKORES_CONT void* GetPointer() const;
 
  VISKORES_CONT viskores::BufferSizeType GetSize() const;
 
  VISKORES_CONT viskores::cont::DeviceAdapterId GetDevice() const;
 
  VISKORES_CONT BufferInfo();
  VISKORES_CONT ~BufferInfo();
 
  VISKORES_CONT BufferInfo(const BufferInfo& src);
  VISKORES_CONT BufferInfo(BufferInfo&& src);
 
  VISKORES_CONT BufferInfo& operator=(const BufferInfo& src);
  VISKORES_CONT BufferInfo& operator=(BufferInfo&& src);
 
  VISKORES_CONT BufferInfo(const BufferInfo& src, viskores::cont::DeviceAdapterId device);
  VISKORES_CONT BufferInfo(BufferInfo&& src, viskores::cont::DeviceAdapterId device);
 
  using Deleter = void(void* container);
 
  using Reallocater = void(void*& memory,
                           void*& container,
                           viskores::BufferSizeType oldSize,
                           viskores::BufferSizeType newSize);
 
  VISKORES_CONT BufferInfo(viskores::cont::DeviceAdapterId device,
                           void* memory,
                           void* container,
                           viskores::BufferSizeType size,
                           Deleter deleter,
                           Reallocater reallocater);
 
  VISKORES_CONT void Reallocate(viskores::BufferSizeType newSize);
 
  VISKORES_CONT TransferredBuffer TransferOwnership();
 
private:
  detail::BufferInfoInternals* Internals;
  viskores::cont::DeviceAdapterId Device;
};
 
 
struct TransferredBuffer
{
  void* Memory;
  void* Container;
  BufferInfo::Deleter* Delete;
  BufferInfo::Reallocater* Reallocate;
  viskores::BufferSizeType Size;
};
 
VISKORES_CONT_EXPORT VISKORES_CONT viskores::cont::internal::BufferInfo AllocateOnHost(
  viskores::BufferSizeType size);
 
class VISKORES_CONT_EXPORT DeviceAdapterMemoryManagerBase
{
public:
  VISKORES_CONT virtual ~DeviceAdapterMemoryManagerBase();
 
  VISKORES_CONT virtual viskores::cont::internal::BufferInfo Allocate(
    viskores::BufferSizeType size) const = 0;
 
  VISKORES_CONT void Reallocate(viskores::cont::internal::BufferInfo& buffer,
                                viskores::BufferSizeType newSize) const;
 
  VISKORES_CONT BufferInfo
  ManageArray(void* memory,
              void* container,
              viskores::BufferSizeType size,
              viskores::cont::internal::BufferInfo::Deleter deleter,
              viskores::cont::internal::BufferInfo::Reallocater reallocater) const;
 
  VISKORES_CONT virtual viskores::cont::DeviceAdapterId GetDevice() const = 0;
 
  VISKORES_CONT virtual viskores::cont::internal::BufferInfo CopyHostToDevice(
    const viskores::cont::internal::BufferInfo& src) const = 0;
 
  VISKORES_CONT virtual void CopyHostToDevice(
    const viskores::cont::internal::BufferInfo& src,
    const viskores::cont::internal::BufferInfo& dest) const = 0;
 
  VISKORES_CONT virtual viskores::cont::internal::BufferInfo CopyDeviceToHost(
    const viskores::cont::internal::BufferInfo& src) const = 0;
 
  VISKORES_CONT virtual void CopyDeviceToHost(
    const viskores::cont::internal::BufferInfo& src,
    const viskores::cont::internal::BufferInfo& dest) const = 0;
 
  VISKORES_CONT virtual viskores::cont::internal::BufferInfo CopyDeviceToDevice(
    const viskores::cont::internal::BufferInfo& src) const = 0;
 
  VISKORES_CONT virtual void CopyDeviceToDevice(
    const viskores::cont::internal::BufferInfo& src,
    const viskores::cont::internal::BufferInfo& dest) const = 0;
 
 
  VISKORES_CONT virtual void* AllocateRawPointer(viskores::BufferSizeType size) const;
 
  VISKORES_CONT virtual void CopyDeviceToDeviceRawPointer(const void* src,
                                                          void* dest,
                                                          viskores::BufferSizeType size) const;
 
  VISKORES_CONT virtual void DeleteRawPointer(void*) const = 0;
};
 
template <typename DeviceAdapterTag>
class DeviceAdapterMemoryManager;
 
VISKORES_CONT_EXPORT VISKORES_CONT void HostDeleter(void*);
VISKORES_CONT_EXPORT VISKORES_CONT void* HostAllocate(viskores::BufferSizeType);
VISKORES_CONT_EXPORT VISKORES_CONT void HostReallocate(void*&,
                                                       void*&,
                                                       viskores::BufferSizeType,
                                                       viskores::BufferSizeType);
 
 
VISKORES_CONT_EXPORT VISKORES_CONT void InvalidRealloc(void*&,
                                                       void*&,
                                                       viskores::BufferSizeType,
                                                       viskores::BufferSizeType);
 
// Deletes a container object by casting it to a pointer of a given type (the template argument)
// and then using delete[] on the object.
template <typename T>
VISKORES_CONT inline void SimpleArrayDeleter(void* container_)
{
  T* container = reinterpret_cast<T*>(container_);
  delete[] container;
}
 
// Reallocates a standard C array. Note that the allocation method is different than the default
// host allocation of viskores::cont::internal::BufferInfo and may be less efficient.
template <typename T>
VISKORES_CONT inline void SimpleArrayReallocater(void*& memory,
                                                 void*& container,
                                                 viskores::BufferSizeType oldSize,
                                                 viskores::BufferSizeType newSize)
{
  VISKORES_ASSERT(memory == container);
  VISKORES_ASSERT(static_cast<std::size_t>(newSize) % sizeof(T) == 0);
 
  // If the new size is not much smaller than the old size, just reuse the buffer (and waste a
  // little memory).
  if ((newSize > ((3 * oldSize) / 4)) && (newSize <= oldSize))
  {
    return;
  }
 
  void* newBuffer = new T[static_cast<std::size_t>(newSize) / sizeof(T)];
  std::memcpy(newBuffer, memory, static_cast<std::size_t>(newSize < oldSize ? newSize : oldSize));
 
  if (memory != nullptr)
  {
    SimpleArrayDeleter<T>(memory);
  }
 
  memory = container = newBuffer;
}
 
// Deletes a container object by casting it to a pointer of a given type (the template argument)
// and then using delete on the object.
template <typename T>
VISKORES_CONT inline void CastDeleter(void* container_)
{
  T* container = reinterpret_cast<T*>(container_);
  delete container;
}
 
template <typename T, typename Allocator>
VISKORES_CONT inline void StdVectorDeleter(void* container)
{
  CastDeleter<std::vector<T, Allocator>>(container);
}
 
template <typename T, typename Allocator>
VISKORES_CONT inline void StdVectorReallocater(void*& memory,
                                               void*& container,
                                               viskores::BufferSizeType oldSize,
                                               viskores::BufferSizeType newSize)
{
  using vector_type = std::vector<T, Allocator>;
  vector_type* vector = reinterpret_cast<vector_type*>(container);
  VISKORES_ASSERT(vector->empty() || (memory == vector->data()));
  VISKORES_ASSERT(oldSize == static_cast<viskores::BufferSizeType>(vector->size() * sizeof(T)));
 
  vector->resize(static_cast<std::size_t>(newSize));
  memory = vector->data();
}
}
}
} // namespace viskores::cont::internal
 
#endif //viskores_cont_internal_DeviceAdapterMemoryManager_h