Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge topic 'leverage_move_constructors'

Browse Source 
94bd79b0 Leverage std::move to help FunctionInterface make less copies.

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !691
This commit is contained in:
Robert Maynard 2017-02-15 13:22:58 +00:00 committed by Kitware Robot
commit 2600b3d890
5 changed files with 175 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
vtkm/cont/ArrayHandle.h
View File

@ -245,11 +245,7 @@ public:
/// Constructs an empty ArrayHandle. Typically used for output or
/// intermediate arrays that will be filled by a VTKm algorithm.
///
VTKM_CONT ArrayHandle() : Internals(new InternalStruct)
{
this->Internals->ControlArrayValid = false;
this->Internals->ExecutionArrayValid = false;
}
VTKM_CONT ArrayHandle();
/// Copy constructor.
///
@ -258,22 +254,23 @@ public:
/// with CUDA), then the automatically generated copy constructor could be
/// created for all devices, and it would not be valid for all devices.
///
VTKM_CONT
ArrayHandle(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
: Internals(src.Internals)
{ }
ArrayHandle(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src);
/// Move constructor.
///
/// Implemented so that it is defined exclusively in the control environment.
/// If there is a separate device for the execution environment (for example,
/// with CUDA), then the automatically generated move constructor could be
/// created for all devices, and it would not be valid for all devices.
///
ArrayHandle(vtkm::cont::ArrayHandle<ValueType,StorageTag> &&src);
/// Special constructor for subclass specializations that need to set the
/// initial state of the control array. When this constructor is used, it
/// is assumed that the control array is valid.
///
ArrayHandle(const StorageType &storage)
: Internals(new InternalStruct)
{
this->Internals->ControlArray = storage;
this->Internals->ControlArrayValid = true;
this->Internals->ExecutionArrayValid = false;
}
ArrayHandle(const StorageType &storage);
/// Destructs an empty ArrayHandle.
///
@ -282,17 +279,19 @@ public:
/// with CUDA), then the automatically generated destructor could be
/// created for all devices, and it would not be valid for all devices.
///
~ArrayHandle() { }
~ArrayHandle();
/// \brief Copies an ArrayHandle
///
VTKM_CONT
vtkm::cont::ArrayHandle<ValueType,StorageTag> &
operator=(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src)
{
this->Internals = src.Internals;
return *this;
}
operator=(const vtkm::cont::ArrayHandle<ValueType,StorageTag> &src);
/// \brief Move and Assignment of an ArrayHandle
///
VTKM_CONT
vtkm::cont::ArrayHandle<ValueType,StorageTag> &
operator=(vtkm::cont::ArrayHandle<ValueType,StorageTag> &&src);
/// Like a pointer, two \c ArrayHandles are considered equal if they point
/// to the same location in memory.

48
vtkm/cont/ArrayHandle.hxx
View File

@ -21,6 +21,54 @@
namespace vtkm {
namespace cont {
template<typename T, typename S>
ArrayHandle<T,S>::ArrayHandle()
: Internals(new InternalStruct)
{
this->Internals->ControlArrayValid = false;
this->Internals->ExecutionArrayValid = false;
}
template<typename T, typename S>
ArrayHandle<T,S>::ArrayHandle(const ArrayHandle<T,S> &src)
: Internals(src.Internals)
{ }
template<typename T, typename S>
ArrayHandle<T,S>::ArrayHandle(ArrayHandle<T,S> &&src)
: Internals(std::move(src.Internals))
{ }
template<typename T, typename S>
ArrayHandle<T,S>::ArrayHandle(const typename ArrayHandle<T,S>::StorageType &storage)
: Internals(new InternalStruct)
{
this->Internals->ControlArray = storage;
this->Internals->ControlArrayValid = true;
this->Internals->ExecutionArrayValid = false;
}
template<typename T, typename S>
ArrayHandle<T,S>::~ArrayHandle()
{
}
template<typename T, typename S>
ArrayHandle<T,S>&
ArrayHandle<T,S>::operator=(const ArrayHandle<T,S> &src)
{
this->Internals = src.Internals;
return *this;
}
template<typename T, typename S>
ArrayHandle<T,S>&
ArrayHandle<T,S>::operator=(ArrayHandle<T,S> &&src)
{
this->Internals = std::move(src.Internals);
return *this;
}
template<typename T, typename S>
typename ArrayHandle<T,S>::StorageType&
ArrayHandle<T,S>::GetStorage()

30
vtkm/internal/FunctionInterface.h
View File

@ -25,6 +25,8 @@
#include <vtkm/internal/IndexTag.h>
#include <vtkm/internal/FunctionInterfaceDetailPre.h>
#include <utility>
namespace vtkm {
namespace internal {
@ -42,30 +44,34 @@ struct IdentityFunctor {
// These functions exist to help copy components of a FunctionInterface.
template<vtkm::IdComponent NumToCopy, vtkm::IdComponent ParameterIndex = 1>
struct FunctionInterfaceCopyParameters {
template<vtkm::IdComponent NumToMove, vtkm::IdComponent ParameterIndex = 1>
struct FunctionInterfaceMoveParameters {
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename DestSignature, typename SrcSignature>
static
VTKM_EXEC_CONT
void Copy(vtkm::internal::detail::ParameterContainer<DestSignature> &dest,
void Move(vtkm::internal::detail::ParameterContainer<DestSignature> &dest,
const vtkm::internal::detail::ParameterContainer<SrcSignature> &src)
{
ParameterContainerAccess<ParameterIndex> pca;
pca.Set( dest, pca.Get(src) );
FunctionInterfaceCopyParameters<NumToCopy-1,ParameterIndex+1>::Copy(dest, src);
// using forwarding_type = typename AtType<ParameterIndex, SrcSignature>::type;
pca.Move( dest, src );
// std::forward<forwarding_type>(pca.Get(src)) );
// pca.Get(src));
FunctionInterfaceMoveParameters<NumToMove-1,ParameterIndex+1>::Move(dest, src);
}
};
template<vtkm::IdComponent ParameterIndex>
struct FunctionInterfaceCopyParameters<0, ParameterIndex> {
struct FunctionInterfaceMoveParameters<0, ParameterIndex> {
template<typename DestSignature, typename SrcSignature>
static
VTKM_EXEC_CONT
void Copy(vtkm::internal::detail::ParameterContainer<DestSignature> &,
void Move(vtkm::internal::detail::ParameterContainer<DestSignature> &,
const vtkm::internal::detail::ParameterContainer<SrcSignature> &)
{
// Nothing left to copy.
// Nothing left to move.
}
};
@ -539,13 +545,13 @@ public:
typedef typename detail::ReplaceType<ComponentSig,ParameterIndex, NewType>::type ReplaceSigType;
FunctionInterface< ReplaceSigType > replacedFuncInterface;
detail::FunctionInterfaceCopyParameters<ParameterIndex-1>::
Copy(replacedFuncInterface.Parameters, this->Parameters);
detail::FunctionInterfaceMoveParameters<ParameterIndex-1>::
Move(replacedFuncInterface.Parameters, this->Parameters);
replacedFuncInterface.template SetParameter<ParameterIndex>(newParameter);
detail::FunctionInterfaceCopyParameters<ARITY-ParameterIndex,ParameterIndex+1>::
Copy(replacedFuncInterface.Parameters, this->Parameters);
detail::FunctionInterfaceMoveParameters<ARITY-ParameterIndex,ParameterIndex+1>::
Move(replacedFuncInterface.Parameters, this->Parameters);
return replacedFuncInterface;
}

80
vtkm/internal/FunctionInterfaceDetailPre.h
View File

@ -293,6 +293,14 @@ struct ParameterContainerAccess<1> {
const typename AtType<1, FunctionSignature>::type &value) {
parameters.Parameter1 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter1 = std::move(src.Parameter1);
}
};
template<>
@ -313,6 +321,14 @@ struct ParameterContainerAccess<2> {
const typename AtType<2, FunctionSignature>::type &value) {
parameters.Parameter2 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter2 = std::move(src.Parameter2);
}
};
template<>
@ -333,6 +349,14 @@ struct ParameterContainerAccess<3> {
const typename AtType<3, FunctionSignature>::type &value) {
parameters.Parameter3 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter3 = std::move(src.Parameter3);
}
};
template<>
@ -353,6 +377,14 @@ struct ParameterContainerAccess<4> {
const typename AtType<4, FunctionSignature>::type &value) {
parameters.Parameter4 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter4 = std::move(src.Parameter4);
}
};
template<>
@ -373,6 +405,14 @@ struct ParameterContainerAccess<5> {
const typename AtType<5, FunctionSignature>::type &value) {
parameters.Parameter5 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter5 = std::move(src.Parameter5);
}
};
template<>
@ -393,6 +433,14 @@ struct ParameterContainerAccess<6> {
const typename AtType<6, FunctionSignature>::type &value) {
parameters.Parameter6 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter6 = std::move(src.Parameter6);
}
};
template<>
@ -413,6 +461,14 @@ struct ParameterContainerAccess<7> {
const typename AtType<7, FunctionSignature>::type &value) {
parameters.Parameter7 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter7 = std::move(src.Parameter7);
}
};
template<>
@ -433,6 +489,14 @@ struct ParameterContainerAccess<8> {
const typename AtType<8, FunctionSignature>::type &value) {
parameters.Parameter8 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter8 = std::move(src.Parameter8);
}
};
template<>
@ -453,6 +517,14 @@ struct ParameterContainerAccess<9> {
const typename AtType<9, FunctionSignature>::type &value) {
parameters.Parameter9 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter9 = std::move(src.Parameter9);
}
};
template<>
@ -473,6 +545,14 @@ struct ParameterContainerAccess<10> {
const typename AtType<10, FunctionSignature>::type &value) {
parameters.Parameter10 = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter10 = std::move(src.Parameter10);
}
};

8
vtkm/internal/FunctionInterfaceDetailPre.h.in
View File

@ -195,6 +195,14 @@ struct ParameterContainerAccess<$(param_index)> {
const typename AtType<$(param_index), FunctionSignature>::type &value) {
parameters.Parameter$(param_index) = value;
}
VTKM_SUPPRESS_EXEC_WARNINGS
template<typename FunctionSignatureDest, typename FunctionSignatureSrc>
VTKM_EXEC_CONT
void Move(ParameterContainer<FunctionSignatureDest> &dest,
const ParameterContainer<FunctionSignatureSrc> &src) {
dest.Parameter$(param_index) = std::move(src.Parameter$(param_index));
}
};
$endfor\