Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
b13a088558
vtk-m/vtkm/cont/internal/ArrayHandleBasicImpl.h

303 lines
10 KiB
C
Raw Normal View History

Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
// 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_internal_ArrayHandleBasicImpl_h
#define vtk_m_cont_internal_ArrayHandleBasicImpl_h
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
#include <vtkm/cont/ArrayHandle.h>
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
#include <vtkm/cont/StorageBasic.h>
#include <type_traits>
namespace vtkm
{
namespace cont
{
namespace internal
{
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
struct ArrayHandleImpl;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
/// Type-agnostic container for an execution memory buffer.
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
struct VTKM_CONT_EXPORT TypelessExecutionArray
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
{
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
TypelessExecutionArray(const ArrayHandleImpl* data);
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
void*& Array;
void*& ArrayEnd;
void*& ArrayCapacity;
Reuse user-provided cuda device pointers when possible.
2017-08-03 16:55:31 +00:00
// Used by cuda to detect and share managed memory allocations.
const void* ArrayControl;
const void* ArrayControlCapacity;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
};
/// Factory that generates execution portals for basic storage.
template <typename T, typename DeviceTag>
struct ExecutionPortalFactoryBasic
#ifndef VTKM_DOXYGEN_ONLY
;
#else // VTKM_DOXYGEN_ONLY
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
{
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
/// The portal type.
using PortalType = SomePortalType;
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
/// The cont portal type.
using ConstPortalType = SomePortalType;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
/// Create a portal to access the execution data from @a start to @a end.
VTKM_CONT
static PortalType CreatePortal(ValueType* start, ValueType* end);
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
/// Create a const portal to access the execution data from @a start to @a end.
VTKM_CONT
static PortalConstType CreatePortalConst(const ValueType* start, const ValueType* end);
};
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
#endif // VTKM_DOXYGEN_ONLY
/// Typeless interface for interacting with a execution memory buffer when using basic storage.
struct VTKM_CONT_EXPORT ExecutionArrayInterfaceBasicBase
{
Refactor ExecutionArrayInterfaceBasic to use inheriting constructors
2018-07-25 16:02:59 +00:00
VTKM_CONT explicit ExecutionArrayInterfaceBasicBase(StorageBasicBase& storage);
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
VTKM_CONT virtual ~ExecutionArrayInterfaceBasicBase();
VTKM_CONT
virtual DeviceAdapterId GetDeviceId() const = 0;
/// If @a execArray's base pointer is null, allocate a new buffer.
/// If (capacity - base) < @a numBytes, the buffer will be freed and
/// reallocated. If (capacity - base) >= numBytes, a new end is marked.
VTKM_CONT
Refactor vtk-m storage basic to generate less code By moving all common operations to a parent class we can significantly reduce the vtk-m library size.
2018-02-09 21:17:39 +00:00
virtual void Allocate(TypelessExecutionArray& execArray,
vtkm::Id numberOfValues,
vtkm::UInt64 sizeOfValue) const = 0;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
/// Release the buffer held by @a execArray and reset all pointer to null.
VTKM_CONT
virtual void Free(TypelessExecutionArray& execArray) const = 0;
/// Copy @a numBytes from @a controlPtr to @a executionPtr.
VTKM_CONT
virtual void CopyFromControl(const void* controlPtr,
void* executionPtr,
Use vtkm::UInt64 for byte sizes. vtkm::Id could be just 32bits, which limits the number of values we would be able to store for large arrays.
2017-09-18 17:03:26 +00:00
vtkm::UInt64 numBytes) const = 0;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
/// Copy @a numBytes from @a executionPtr to @a controlPtr.
VTKM_CONT
virtual void CopyToControl(const void* executionPtr,
void* controlPtr,
Use vtkm::UInt64 for byte sizes. vtkm::Id could be just 32bits, which limits the number of values we would be able to store for large arrays.
2017-09-18 17:03:26 +00:00
vtkm::UInt64 numBytes) const = 0;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
ExecutionArrayInterface now can hint at how allocated memory will be used. Certain backends desire the ability to mark allocations as being used for reading versus writing to improve performance.
2017-11-02 12:50:58 +00:00
VTKM_CONT virtual void UsingForRead(const void* controlPtr,
const void* executionPtr,
vtkm::UInt64 numBytes) const = 0;
VTKM_CONT virtual void UsingForWrite(const void* controlPtr,
const void* executionPtr,
vtkm::UInt64 numBytes) const = 0;
VTKM_CONT virtual void UsingForReadWrite(const void* controlPtr,
const void* executionPtr,
vtkm::UInt64 numBytes) const = 0;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
protected:
StorageBasicBase& ControlStorage;
};
/**
* Specializations should inherit from and implement the API of
* ExecutionArrayInterfaceBasicBase.
*/
template <typename DeviceTag>
struct ExecutionArrayInterfaceBasic;
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
struct VTKM_CONT_EXPORT ArrayHandleImpl
{
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
VTKM_CONT
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
template <typename T>
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
explicit ArrayHandleImpl(T)
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
: ControlArrayValid(false)
, ControlArray(new vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>())
, ExecutionInterface(nullptr)
, ExecutionArrayValid(false)
, ExecutionArray(nullptr)
, ExecutionArrayEnd(nullptr)
, ExecutionArrayCapacity(nullptr)
{
}
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
VTKM_CONT
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
template <typename T>
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
explicit ArrayHandleImpl(
const vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>& storage)
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
: ControlArrayValid(true)
, ControlArray(new vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>(storage))
, ExecutionInterface(nullptr)
, ExecutionArrayValid(false)
, ExecutionArray(nullptr)
, ExecutionArrayEnd(nullptr)
, ExecutionArrayCapacity(nullptr)
{
}
VTK-m ArrayHandle can now take ownership of a user allocated memory location Previously memory that was allocated outside of VTK-m was impossible to transfer to VTK-m as we didn't know how to free it. By extending the ArrayHandle constructors to support a Storage object that is being moved, we can clearly express that the ArrayHandle now owns memory it didn't allocate. Here is an example of how this is done: ```cpp T* buffer = new T[100]; auto user_free_function = [](void* ptr) { delete[] static_cast<T*>(ptr); }; vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic> storage(buffer, 100, user_free_function); vtkm::cont::ArrayHandle<T> arrayHandle(std::move(storage)); ```
2018-04-04 15:08:51 +00:00
VTKM_CONT
template <typename T>
explicit ArrayHandleImpl(vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>&& storage)
: ControlArrayValid(true)
, ControlArray(
new vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>(std::move(storage)))
, ExecutionInterface(nullptr)
, ExecutionArrayValid(false)
, ExecutionArray(nullptr)
, ExecutionArrayEnd(nullptr)
, ExecutionArrayCapacity(nullptr)
{
}
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
VTKM_CONT ~ArrayHandleImpl();
VTKM_CONT ArrayHandleImpl(const ArrayHandleImpl&) = delete;
VTKM_CONT void operator=(const ArrayHandleImpl&) = delete;
//Throws ErrorInternal if ControlArrayValid == false
VTKM_CONT void CheckControlArrayValid() noexcept(false);
VTKM_CONT vtkm::Id GetNumberOfValues(vtkm::UInt64 sizeOfT) const;
VTKM_CONT void Allocate(vtkm::Id numberOfValues, vtkm::UInt64 sizeOfT);
VTKM_CONT void Shrink(vtkm::Id numberOfValues, vtkm::UInt64 sizeOfT);
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
VTKM_CONT void SyncControlArray(vtkm::UInt64 sizeofT) const;
VTKM_CONT void ReleaseResources();
VTKM_CONT void ReleaseResourcesExecutionInternal();
VTKM_CONT void PrepareForInput(vtkm::UInt64 sizeofT) const;
VTKM_CONT void PrepareForOutput(vtkm::Id numVals, vtkm::UInt64 sizeofT);
VTKM_CONT void PrepareForInPlace(vtkm::UInt64 sizeofT);
// Check if the current device matches the last one. If they don't match
// this moves all data back from execution environment and deletes the
// ExecutionInterface instance.
// Returns true when the caller needs to reallocate ExecutionInterface
VTKM_CONT bool PrepareForDevice(DeviceAdapterId devId, vtkm::UInt64 sizeofT) const;
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
VTKM_CONT DeviceAdapterId GetDeviceAdapterId() const;
mutable bool ControlArrayValid;
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
StorageBasicBase* ControlArray;
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
mutable ExecutionArrayInterfaceBasicBase* ExecutionInterface;
mutable bool ExecutionArrayValid;
mutable void* ExecutionArray;
mutable void* ExecutionArrayEnd;
mutable void* ExecutionArrayCapacity;
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
};
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
} // end namespace internal
/// Specialization of ArrayHandle for Basic storage. The goal here is to reduce
/// the amount of codegen for the common case of Basic storage when we build
/// the common arrays into libvtkm_cont.
template <typename T>
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
class VTKM_ALWAYS_EXPORT ArrayHandle<T, ::vtkm::cont::StorageTagBasic>
: public ::vtkm::cont::internal::ArrayHandleBase
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
{
private:
using Thisclass = ArrayHandle<T, ::vtkm::cont::StorageTagBasic>;
template <typename DeviceTag>
using PortalFactory = vtkm::cont::internal::ExecutionPortalFactoryBasic<T, DeviceTag>;
public:
using StorageTag = ::vtkm::cont::StorageTagBasic;
using StorageType = vtkm::cont::internal::Storage<T, StorageTag>;
using ValueType = T;
using PortalControl = typename StorageType::PortalType;
using PortalConstControl = typename StorageType::PortalConstType;
template <typename DeviceTag>
struct ExecutionTypes
{
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceTag);
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
using Portal = typename PortalFactory<DeviceTag>::PortalType;
using PortalConst = typename PortalFactory<DeviceTag>::PortalConstType;
};
VTKM_CONT ArrayHandle();
VTKM_CONT ArrayHandle(const Thisclass& src);
Make the ArrayHandle move constructors noexcept. std::containers only activate fast emplace operations if the T types move operators are noexcept
2018-10-23 20:21:05 +00:00
VTKM_CONT ArrayHandle(Thisclass&& src) noexcept;
VTK-m ArrayHandle can now take ownership of a user allocated memory location Previously memory that was allocated outside of VTK-m was impossible to transfer to VTK-m as we didn't know how to free it. By extending the ArrayHandle constructors to support a Storage object that is being moved, we can clearly express that the ArrayHandle now owns memory it didn't allocate. Here is an example of how this is done: ```cpp T* buffer = new T[100]; auto user_free_function = [](void* ptr) { delete[] static_cast<T*>(ptr); }; vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic> storage(buffer, 100, user_free_function); vtkm::cont::ArrayHandle<T> arrayHandle(std::move(storage)); ```
2018-04-04 15:08:51 +00:00
Make the ArrayHandle move constructors noexcept. std::containers only activate fast emplace operations if the T types move operators are noexcept
2018-10-23 20:21:05 +00:00
VTKM_CONT ArrayHandle(const StorageType& storage) noexcept;
VTKM_CONT ArrayHandle(StorageType&& storage) noexcept;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
VTKM_CONT ~ArrayHandle();
VTKM_CONT Thisclass& operator=(const Thisclass& src);
Make the ArrayHandle move constructors noexcept. std::containers only activate fast emplace operations if the T types move operators are noexcept
2018-10-23 20:21:05 +00:00
VTKM_CONT Thisclass& operator=(Thisclass&& src) noexcept;
Add equality operators that handle different handle types. In generic code, it's a pain to use the equality operators since they requires the ValueType and Storage to match, else the operator is undefined. This commit adds operators for such comparisons, as well as a unit test.
2017-10-11 15:34:28 +00:00
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
VTKM_CONT bool operator==(const Thisclass& rhs) const;
VTKM_CONT bool operator!=(const Thisclass& rhs) const;
Add equality operators that handle different handle types. In generic code, it's a pain to use the equality operators since they requires the ValueType and Storage to match, else the operator is undefined. This commit adds operators for such comparisons, as well as a unit test.
2017-10-11 15:34:28 +00:00
template <typename VT, typename ST>
VTKM_CONT bool operator==(const ArrayHandle<VT, ST>&) const;
template <typename VT, typename ST>
VTKM_CONT bool operator!=(const ArrayHandle<VT, ST>&) const;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
VTKM_CONT StorageType& GetStorage();
VTKM_CONT const StorageType& GetStorage() const;
VTKM_CONT PortalControl GetPortalControl();
VTKM_CONT PortalConstControl GetPortalConstControl() const;
VTKM_CONT vtkm::Id GetNumberOfValues() const;
VTKM_CONT void Allocate(vtkm::Id numberOfValues);
VTKM_CONT void Shrink(vtkm::Id numberOfValues);
VTKM_CONT void ReleaseResourcesExecution();
VTKM_CONT void ReleaseResources();
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::PortalConst PrepareForInput(
DeviceAdapterTag device) const;
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal PrepareForOutput(
vtkm::Id numVals,
DeviceAdapterTag device);
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal PrepareForInPlace(
DeviceAdapterTag device);
template <typename DeviceAdapterTag>
VTKM_CONT void PrepareForDevice(DeviceAdapterTag) const;
Deduce device adapter tag in interop::TransferToOpenGL.
2017-08-11 19:36:24 +00:00
VTKM_CONT DeviceAdapterId GetDeviceAdapterId() const;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
VTKM_CONT void SyncControlArray() const;
VTKM_CONT void ReleaseResourcesExecutionInternal();
vtk-m ArrayHandle + basic holds control data by StorageBasicBase By making the array handle hold the control side data by the parent storage class we remove significant code generation.
2018-02-12 18:09:43 +00:00
std::shared_ptr<internal::ArrayHandleImpl> Internals;
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
};
} // end namespace cont
} // end namespace vtkm
vtk-m ArrayHandle + basic storage has an optimized PrepareForDevice method By hard coding the PrepareForDevice to know about all the different VTK-m devices, we can have a single base class do the execution allocation, and not have that logic repeated in each child class.
2018-02-12 19:45:59 +00:00
#ifndef vtkm_cont_internal_ArrayHandleImpl_cxx
#ifdef VTKM_MSVC
extern template class VTKM_CONT_TEMPLATE_EXPORT
std::shared_ptr<vtkm::cont::internal::ArrayHandleImpl>;
#endif
#endif
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
#ifndef vtk_m_cont_internal_ArrayHandleBasicImpl_hxx
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
#include <vtkm/cont/internal/ArrayHandleBasicImpl.hxx>
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
#endif
Refactor array transfer logic for basic storage. The old templated array transfer mechanism generated a lot of code that ended up doing a simple, type-agnostic memcpy for most devices. This patch specialized array handles for basic storage and uses a fast-path array transfer implementation. This reduces the size of the vtkm_cont library by 27% on gcc (from 6.2MB to 4.5MB).
2017-06-23 13:33:28 +00:00
#endif // vtk_m_cont_internal_ArrayHandleBasicImpl_h
Reference in New Issue Copy Permalink