Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Add ArrayHandle Serialization

Browse Source
This commit is contained in:
Sujin Philip 2018-06-08 11:56:40 -04:00
parent 8d0f441e1b
commit fd89dfc89b
31 changed files with 2458 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/redistribute_points/RedistributePoints.h
View File

@ -22,7 +22,7 @@
#include <vtkm/cont/Algorithm.h>
#include <vtkm/cont/AssignerMultiBlock.h>
#include <vtkm/cont/BoundsGlobalCompute.h>
#include <vtkm/cont/diy/Serialization.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/filter/ExtractPoints.h>
#include <vtkm/filter/Filter.h>

45
vtkm/cont/ArrayHandle.h
View File

@ -29,6 +29,7 @@
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/StorageBasic.h>
@ -674,6 +675,50 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle(
}
} //namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename T>
struct TypeString<ArrayHandle<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH<" + TypeString<T>::Get() + ">";
return name;
}
};
namespace internal
{
template <typename T, typename S>
void VTKM_CONT ArrayHandleDefaultSerialization(diy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandle<T, S>& obj);
} // internal
}
} // vtkm::cont
namespace diy
{
template <typename T>
struct Serialization<vtkm::cont::ArrayHandle<T>>
{
static VTKM_CONT void save(BinaryBuffer& bb, const vtkm::cont::ArrayHandle<T>& obj)
{
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, obj);
}
static VTKM_CONT void load(BinaryBuffer& bb, vtkm::cont::ArrayHandle<T>& obj);
};
} // diy
#include <vtkm/cont/ArrayHandle.hxx>
#include <vtkm/cont/internal/ArrayHandleBasicImpl.h>
#include <vtkm/cont/internal/ArrayExportMacros.h>

45
vtkm/cont/ArrayHandle.hxx
View File

@ -345,4 +345,49 @@ void ArrayHandle<T, S>::SyncControlArray() const
}
}
}
} // vtkm::cont
namespace vtkm
{
namespace cont
{
namespace internal
{
template <typename T, typename S>
inline void VTKM_CONT ArrayHandleDefaultSerialization(diy::BinaryBuffer& bb,
const vtkm::cont::ArrayHandle<T, S>& obj)
{
vtkm::Id count = obj.GetNumberOfValues();
diy::save(bb, count);
auto portal = obj.GetPortalConstControl();
for (vtkm::Id i = 0; i < count; ++i)
{
diy::save(bb, portal.Get(i));
}
}
}
}
} // vtkm::cont::internal
namespace diy
{
template <typename T>
VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T>>::load(BinaryBuffer& bb,
vtkm::cont::ArrayHandle<T>& obj)
{
vtkm::Id count = 0;
diy::load(bb, count);
obj.Allocate(count);
auto portal = obj.GetPortalControl();
for (vtkm::Id i = 0; i < count; ++i)
{
T val{};
diy::load(bb, val);
portal.Set(i, val);
}
}
} // diy

90
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -181,15 +181,16 @@ struct ArrayHandleCartesianProductTraits
using Superclass = vtkm::cont::ArrayHandle<ValueType, Tag>;
};
template <typename T, typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
class Storage<T, StorageTagCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>>
template <typename FirstHandleType, typename SecondHandleType, typename ThirdHandleType>
class Storage<vtkm::Vec<typename FirstHandleType::ValueType, 3>,
StorageTagCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>>
{
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
VTKM_IS_ARRAY_HANDLE(ThirdHandleType);
public:
using ValueType = T;
using ValueType = vtkm::Vec<typename FirstHandleType::ValueType, 3>;
using PortalType =
vtkm::exec::internal::ArrayPortalCartesianProduct<ValueType,
@ -277,21 +278,22 @@ private:
ThirdHandleType ThirdArray;
};
template <typename T,
typename FirstHandleType,
template <typename FirstHandleType,
typename SecondHandleType,
typename ThirdHandleType,
typename Device>
class ArrayTransfer<T,
class ArrayTransfer<vtkm::Vec<typename FirstHandleType::ValueType, 3>,
StorageTagCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>,
Device>
{
public:
using ValueType = vtkm::Vec<typename FirstHandleType::ValueType, 3>;
private:
using StorageTag = StorageTagCartesianProduct<FirstHandleType, SecondHandleType, ThirdHandleType>;
using StorageType = vtkm::cont::internal::Storage<T, StorageTag>;
using StorageType = vtkm::cont::internal::Storage<ValueType, StorageTag>;
public:
using ValueType = T;
using PortalControl = typename StorageType::PortalType;
using PortalConstControl = typename StorageType::PortalConstType;
@ -428,4 +430,74 @@ VTKM_CONT
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH1, typename AH2, typename AH3>
struct TypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_CartesianProduct<" + TypeString<AH1>::Get() + "," +
TypeString<AH2>::Get() + "," + TypeString<AH3>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2, typename AH3>
struct TypeString<
vtkm::cont::ArrayHandle<vtkm::Vec<typename AH1::ValueType, 3>,
vtkm::cont::internal::StorageTagCartesianProduct<AH1, AH2, AH3>>>
: TypeString<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH1, typename AH2, typename AH3>
struct Serialization<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
private:
using Type = typename vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetFirstArray());
diy::save(bb, storage.GetSecondArray());
diy::save(bb, storage.GetThirdArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH1 array1;
AH2 array2;
AH3 array3;
diy::load(bb, array1);
diy::load(bb, array2);
diy::load(bb, array3);
obj = vtkm::cont::make_ArrayHandleCartesianProduct(array1, array2, array3);
}
};
template <typename AH1, typename AH2, typename AH3>
struct Serialization<
vtkm::cont::ArrayHandle<vtkm::Vec<typename AH1::ValueType, 3>,
vtkm::cont::internal::StorageTagCartesianProduct<AH1, AH2, AH3>>>
: Serialization<vtkm::cont::ArrayHandleCartesianProduct<AH1, AH2, AH3>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleCartesianProduct_h

52
vtkm/cont/ArrayHandleCast.h
View File

@ -103,4 +103,56 @@ VTKM_CONT
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename T1, typename T2>
struct TypeString<vtkm::cont::internal::Cast<T1, T2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Cast_Functor<" + TypeString<T1>::Get() + "," + TypeString<T2>::Get() + ">";
return name;
}
};
template <typename T, typename AH>
struct TypeString<vtkm::cont::ArrayHandleCast<T, AH>>
: TypeString<
vtkm::cont::ArrayHandleTransform<AH,
vtkm::cont::internal::Cast<typename AH::ValueType, T>,
vtkm::cont::internal::Cast<T, typename AH::ValueType>>>
{
};
}
} // namespace vtkm::cont
namespace diy
{
template <typename T1, typename T2>
struct Serialization<vtkm::cont::internal::Cast<T1, T2>>
{
static VTKM_CONT void save(BinaryBuffer&, const vtkm::cont::internal::Cast<T1, T2>&) {}
static VTKM_CONT void load(BinaryBuffer&, vtkm::cont::internal::Cast<T1, T2>&) {}
};
template <typename T, typename AH>
struct Serialization<vtkm::cont::ArrayHandleCast<T, AH>>
: Serialization<
vtkm::cont::ArrayHandleTransform<AH,
vtkm::cont::internal::Cast<typename AH::ValueType, T>,
vtkm::cont::internal::Cast<T, typename AH::ValueType>>>
{
};
} // diy
#endif // vtk_m_cont_ArrayHandleCast_h

117
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -723,4 +723,121 @@ VTKM_CONT ArrayHandleCompositeVector<ArrayTs...> make_ArrayHandleCompositeVector
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename... AHs>
struct TypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_CompositeVector<" + internal::GetVariadicTypeString(AHs{}...) + ">";
return name;
}
};
template <typename... AHs>
struct TypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::compvec::GetValueType<vtkmstd::tuple<AHs...>>::ValueType,
vtkm::cont::internal::StorageTagCompositeVector<vtkmstd::tuple<AHs...>>>>
: TypeString<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
};
}
} // vtkm::cont
namespace diy
{
namespace internal
{
template <typename Functor, typename TupleType, typename... Args>
inline void TupleForEachImpl(TupleType&& t,
std::integral_constant<size_t, 0>,
Functor&& f,
Args&&... args)
{
f(vtkmstd::get<0>(t), std::forward<Args>(args)...);
}
template <typename Functor, typename TupleType, size_t Index, typename... Args>
inline void TupleForEachImpl(TupleType&& t,
std::integral_constant<size_t, Index>,
Functor&& f,
Args&&... args)
{
TupleForEachImpl(std::forward<TupleType>(t),
std::integral_constant<size_t, Index - 1>{},
std::forward<Functor>(f),
std::forward<Args>(args)...);
f(vtkmstd::get<Index>(t), std::forward<Args>(args)...);
}
template <typename Functor, typename TupleType, typename... Args>
inline void TupleForEach(TupleType&& t, Functor&& f, Args&&... args)
{
constexpr auto size = vtkmstd::tuple_size<typename std::decay<TupleType>::type>::value;
TupleForEachImpl(std::forward<TupleType>(t),
std::integral_constant<size_t, size - 1>{},
std::forward<Functor>(f),
std::forward<Args>(args)...);
}
} // internal
template <typename... AHs>
struct Serialization<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
private:
using Type = typename vtkm::cont::ArrayHandleCompositeVector<AHs...>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
struct SaveFunctor
{
template <typename AH>
void operator()(const AH& ah, BinaryBuffer& bb) const
{
diy::save(bb, ah);
}
};
struct LoadFunctor
{
template <typename AH>
void operator()(AH& ah, BinaryBuffer& bb) const
{
diy::load(bb, ah);
}
};
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
internal::TupleForEach(obj.GetStorage().GetArrayTuple(), SaveFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkmstd::tuple<AHs...> arrayTuple;
internal::TupleForEach(arrayTuple, LoadFunctor{}, bb);
obj = BaseType(typename BaseType::StorageType(arrayTuple));
}
};
template <typename... AHs>
struct Serialization<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::compvec::GetValueType<vtkmstd::tuple<AHs...>>::ValueType,
vtkm::cont::internal::StorageTagCompositeVector<vtkmstd::tuple<AHs...>>>>
: Serialization<vtkm::cont::ArrayHandleCompositeVector<AHs...>>
{
};
} // diy
#endif //vtk_m_ArrayHandleCompositeVector_h

65
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -324,4 +324,69 @@ VTKM_CONT ArrayHandleConcatenate<ArrayHandleType1, ArrayHandleType2> make_ArrayH
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH1, typename AH2>
struct TypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Concatenate<" + TypeString<AH1>::Get() + "," + TypeString<AH2>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2>
struct TypeString<
vtkm::cont::ArrayHandle<typename AH1::ValueType, vtkm::cont::StorageTagConcatenate<AH1, AH2>>>
: TypeString<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH1, typename AH2>
struct Serialization<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
private:
using Type = vtkm::cont::ArrayHandleConcatenate<AH1, AH2>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray1());
diy::save(bb, storage.GetArray2());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH1 array1;
AH2 array2;
diy::load(bb, array1);
diy::load(bb, array2);
obj = vtkm::cont::make_ArrayHandleConcatenate(array1, array2);
}
};
template <typename AH1, typename AH2>
struct Serialization<
vtkm::cont::ArrayHandle<typename AH1::ValueType, vtkm::cont::StorageTagConcatenate<AH1, AH2>>>
: Serialization<vtkm::cont::ArrayHandleConcatenate<AH1, AH2>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleConcatenate_h

36
vtkm/cont/ArrayHandleConstant.h
View File

@ -85,4 +85,40 @@ vtkm::cont::ArrayHandleConstant<T> make_ArrayHandleConstant(T value, vtkm::Id nu
}
} // vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename T>
struct TypeString<vtkm::cont::detail::ConstantFunctor<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_ConstantFunctor<" + TypeString<T>::Get() + ">";
return name;
}
};
template <typename T>
struct TypeString<vtkm::cont::ArrayHandleConstant<T>>
: TypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::ConstantFunctor<T>>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename T>
struct Serialization<vtkm::cont::ArrayHandleConstant<T>>
: Serialization<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::ConstantFunctor<T>>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleConstant_h

72
vtkm/cont/ArrayHandleCounting.h
View File

@ -76,6 +76,12 @@ public:
return *this;
}
VTKM_EXEC_CONT
ValueType GetStart() const { return this->Start; }
VTKM_EXEC_CONT
ValueType GetStep() const { return this->Step; }
VTKM_EXEC_CONT
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
@ -142,4 +148,70 @@ make_ArrayHandleCounting(CountingValueType start, CountingValueType step, vtkm::
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename T>
struct TypeString<vtkm::cont::ArrayHandleCounting<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Counting<" + TypeString<T>::Get() + ">";
return name;
}
};
template <typename T>
struct TypeString<
vtkm::cont::ArrayHandle<T, typename vtkm::cont::ArrayHandleCounting<T>::StorageTag>>
: TypeString<vtkm::cont::ArrayHandleCounting<T>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename T>
struct Serialization<vtkm::cont::ArrayHandleCounting<T>>
{
private:
using Type = vtkm::cont::ArrayHandleCounting<T>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
diy::save(bb, portal.GetStart());
diy::save(bb, portal.GetStep());
diy::save(bb, portal.GetNumberOfValues());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
T start{}, step{};
vtkm::Id count = 0;
diy::load(bb, start);
diy::load(bb, step);
diy::load(bb, count);
obj = vtkm::cont::make_ArrayHandleCounting(start, step, count);
}
};
template <typename T>
struct Serialization<
vtkm::cont::ArrayHandle<T, typename vtkm::cont::ArrayHandleCounting<T>::StorageTag>>
: Serialization<vtkm::cont::ArrayHandleCounting<T>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleCounting_h

65
vtkm/cont/ArrayHandleExtractComponent.h
View File

@ -310,4 +310,69 @@ VTKM_CONT ArrayHandleExtractComponent<ArrayHandleType> make_ArrayHandleExtractCo
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH>
struct TypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_ExtractComponent<" + TypeString<AH>::Get() + ">";
return name;
}
};
template <typename AH>
struct TypeString<
vtkm::cont::ArrayHandle<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType,
vtkm::cont::StorageTagExtractComponent<AH>>>
: TypeString<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH>
struct Serialization<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
private:
using Type = vtkm::cont::ArrayHandleExtractComponent<AH>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetComponent());
diy::save(bb, storage.GetArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkm::IdComponent component = 0;
AH array;
diy::load(bb, component);
diy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleExtractComponent(array, component);
}
};
template <typename AH>
struct Serialization<
vtkm::cont::ArrayHandle<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType,
vtkm::cont::StorageTagExtractComponent<AH>>>
: Serialization<vtkm::cont::ArrayHandleExtractComponent<AH>>
{
};
} // diy
#endif // vtk_m_cont_ArrayHandleExtractComponent_h

62
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -366,4 +366,66 @@ VTKM_CONT vtkm::cont::ArrayHandleGroupVec<ArrayHandleType, NUM_COMPONENTS> make_
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct TypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_GroupVec<" + TypeString<AH>::Get() + "," + std::to_string(NUM_COMPS) + ">";
return name;
}
};
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct TypeString<vtkm::cont::ArrayHandle<vtkm::Vec<typename AH::ValueType, NUM_COMPS>,
vtkm::cont::internal::StorageTagGroupVec<AH, NUM_COMPS>>>
: TypeString<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct Serialization<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
private:
using Type = vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetSourceArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleGroupVec<NUM_COMPS>(array);
}
};
template <typename AH, vtkm::IdComponent NUM_COMPS>
struct Serialization<
vtkm::cont::ArrayHandle<vtkm::Vec<typename AH::ValueType, NUM_COMPS>,
vtkm::cont::internal::StorageTagGroupVec<AH, NUM_COMPS>>>
: Serialization<vtkm::cont::ArrayHandleGroupVec<AH, NUM_COMPS>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleGroupVec_h

66
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -613,4 +613,70 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Id> ConvertNumComponentsToOffsets(
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename SAH, typename OAH>
struct TypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_GroupVecVariable<" + TypeString<SAH>::Get() + "," + TypeString<OAH>::Get() + ">";
return name;
}
};
template <typename SAH, typename OAH>
struct TypeString<
vtkm::cont::ArrayHandle<vtkm::VecFromPortal<typename SAH::PortalControl>,
vtkm::cont::internal::StorageTagGroupVecVariable<SAH, OAH>>>
: TypeString<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename SAH, typename OAH>
struct Serialization<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
private:
using Type = vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetSourceArray());
diy::save(bb, obj.GetStorage().GetOffsetsArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
SAH src;
OAH off;
diy::load(bb, src);
diy::load(bb, off);
obj = vtkm::cont::make_ArrayHandleGroupVecVariable(src, off);
}
};
template <typename SAH, typename OAH>
struct Serialization<
vtkm::cont::ArrayHandle<vtkm::VecFromPortal<typename SAH::PortalControl>,
vtkm::cont::internal::StorageTagGroupVecVariable<SAH, OAH>>>
: Serialization<vtkm::cont::ArrayHandleGroupVecVariable<SAH, OAH>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleGroupVecVariable_h

69
vtkm/cont/ArrayHandleImplicit.h
View File

@ -76,6 +76,9 @@ public:
{
}
VTKM_EXEC_CONT
const FunctorType& GetFunctor() const { return this->Functor; }
VTKM_EXEC_CONT
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
@ -142,4 +145,70 @@ VTKM_CONT vtkm::cont::ArrayHandleImplicit<FunctorType> make_ArrayHandleImplicit(
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename Functor>
struct TypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Implicit<" + TypeString<Functor>::Get() + ">";
return name;
}
};
template <typename Functor>
struct TypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::detail::ArrayHandleImplicitTraits<Functor>::ValueType,
vtkm::cont::StorageTagImplicit<vtkm::cont::detail::ArrayPortalImplicit<Functor>>>>
: TypeString<vtkm::cont::ArrayHandleImplicit<Functor>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename Functor>
struct Serialization<vtkm::cont::ArrayHandleImplicit<Functor>>
{
private:
using Type = vtkm::cont::ArrayHandleImplicit<Functor>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetNumberOfValues());
diy::save(bb, obj.GetPortalConstControl().GetFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkm::Id count = 0;
diy::load(bb, count);
Functor functor;
diy::load(bb, functor);
obj = vtkm::cont::make_ArrayHandleImplicit(functor, count);
}
};
template <typename Functor>
struct Serialization<vtkm::cont::ArrayHandle<
typename vtkm::cont::detail::ArrayHandleImplicitTraits<Functor>::ValueType,
vtkm::cont::StorageTagImplicit<vtkm::cont::detail::ArrayPortalImplicit<Functor>>>>
: Serialization<vtkm::cont::ArrayHandleImplicit<Functor>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleImplicit_h

41
vtkm/cont/ArrayHandleIndex.h
View File

@ -61,4 +61,45 @@ public:
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <>
struct TypeString<vtkm::cont::detail::IndexFunctor>
{
static VTKM_CONT const std::string Get() { return "AH_IndexFunctor"; }
};
template <>
struct TypeString<vtkm::cont::ArrayHandleIndex>
: TypeString<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::IndexFunctor>>
{
};
}
} // vtkm::cont
namespace diy
{
template <>
struct Serialization<vtkm::cont::detail::IndexFunctor>
{
static VTKM_CONT void save(BinaryBuffer&, const vtkm::cont::detail::IndexFunctor&) {}
static VTKM_CONT void load(BinaryBuffer&, vtkm::cont::detail::IndexFunctor&) {}
};
template <>
struct Serialization<vtkm::cont::ArrayHandleIndex>
: Serialization<vtkm::cont::ArrayHandleImplicit<vtkm::cont::detail::IndexFunctor>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleIndex_h

68
vtkm/cont/ArrayHandlePermutation.h
View File

@ -372,4 +372,72 @@ make_ArrayHandlePermutation(IndexArrayHandleType indexArray, ValueArrayHandleTyp
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename IdxAH, typename ValAH>
struct TypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Permutation<" + TypeString<IdxAH>::Get() + "," + TypeString<ValAH>::Get() + ">";
return name;
}
};
template <typename IdxAH, typename ValAH>
struct TypeString<
vtkm::cont::ArrayHandle<typename ValAH::ValueType,
vtkm::cont::internal::StorageTagPermutation<IdxAH, ValAH>>>
: TypeString<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename IdxAH, typename ValAH>
struct Serialization<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
private:
using Type = vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetIndexArray());
diy::save(bb, storage.GetValueArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
IdxAH indices;
ValAH values;
diy::load(bb, indices);
diy::load(bb, values);
obj = vtkm::cont::make_ArrayHandlePermutation(indices, values);
}
};
template <typename IdxAH, typename ValAH>
struct Serialization<
vtkm::cont::ArrayHandle<typename ValAH::ValueType,
vtkm::cont::internal::StorageTagPermutation<IdxAH, ValAH>>>
: Serialization<vtkm::cont::ArrayHandlePermutation<IdxAH, ValAH>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandlePermutation_h

59
vtkm/cont/ArrayHandleReverse.h
View File

@ -243,4 +243,63 @@ VTKM_CONT ArrayHandleReverse<HandleType> make_ArrayHandleReverse(const HandleTyp
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH>
struct TypeString<vtkm::cont::ArrayHandleReverse<AH>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Reverse<" + TypeString<AH>::Get() + ">";
return name;
}
};
template <typename AH>
struct TypeString<
vtkm::cont::ArrayHandle<typename AH::ValueType, vtkm::cont::StorageTagReverse<AH>>>
: TypeString<vtkm::cont::ArrayHandleReverse<AH>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH>
struct Serialization<vtkm::cont::ArrayHandleReverse<AH>>
{
private:
using Type = vtkm::cont::ArrayHandleReverse<AH>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
diy::save(bb, obj.GetStorage().GetArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
obj = vtkm::cont::make_ArrayHandleReverse(array);
}
};
template <typename AH>
struct Serialization<
vtkm::cont::ArrayHandle<typename AH::ValueType, vtkm::cont::StorageTagReverse<AH>>>
: Serialization<vtkm::cont::ArrayHandleReverse<AH>>
{
};
} // diy
#endif // vtk_m_cont_ArrayHandleReverse_h

66
vtkm/cont/ArrayHandleSwizzle.h
View File

@ -398,4 +398,70 @@ make_ArrayHandleSwizzle(const ArrayHandleType& array,
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH, vtkm::IdComponent NComps>
struct TypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Swizzle<" + TypeString<AH>::Get() + "," + std::to_string(NComps) + ">";
return name;
}
};
template <typename AH, vtkm::IdComponent NComps>
struct TypeString<vtkm::cont::ArrayHandle<
vtkm::Vec<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType, NComps>,
vtkm::cont::StorageTagSwizzle<AH, NComps>>>
: TypeString<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH, vtkm::IdComponent NComps>
struct Serialization<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
private:
using Type = vtkm::cont::ArrayHandleSwizzle<AH, NComps>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetMap());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
vtkm::Vec<vtkm::IdComponent, NComps> map;
diy::load(bb, map);
obj = vtkm::cont::make_ArrayHandleSwizzle(array, map);
}
};
template <typename AH, vtkm::IdComponent NComps>
struct Serialization<vtkm::cont::ArrayHandle<
vtkm::Vec<typename vtkm::VecTraits<typename AH::ValueType>::ComponentType, NComps>,
vtkm::cont::StorageTagSwizzle<AH, NComps>>>
: Serialization<vtkm::cont::ArrayHandleSwizzle<AH, NComps>>
{
};
} // diy
#endif // vtk_m_cont_ArrayHandleSwizzle_h

105
vtkm/cont/ArrayHandleTransform.h
View File

@ -737,4 +737,109 @@ make_ArrayHandleTransform(HandleType handle, FunctorType functor, InverseFunctor
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH, typename Functor, typename InvFunctor>
struct TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "AH_Transform<" + TypeString<AH>::Get() + "," +
TypeString<Functor>::Get() + "," + TypeString<InvFunctor>::Get() + ">";
return name;
}
};
template <typename AH, typename Functor>
struct TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Transform<" + TypeString<AH>::Get() + "," + TypeString<Functor>::Get() + ">";
return name;
}
};
template <typename AH, typename Functor, typename InvFunctor>
struct TypeString<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>::ValueType,
vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>>>
: TypeString<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
};
}
} // vtkm::cont
namespace diy
{
template <typename AH, typename Functor>
struct Serialization<vtkm::cont::ArrayHandleTransform<AH, Functor>>
{
private:
using Type = vtkm::cont::ArrayHandleTransform<AH, Functor>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
Functor functor;
diy::load(bb, functor);
obj = vtkm::cont::make_ArrayHandleTransform(array, functor);
}
};
template <typename AH, typename Functor, typename InvFunctor>
struct Serialization<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
private:
using Type = vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetArray());
diy::save(bb, storage.GetFunctor());
diy::save(bb, storage.GetInverseFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH array;
diy::load(bb, array);
Functor functor;
diy::load(bb, functor);
InvFunctor invFunctor;
diy::load(bb, invFunctor);
obj = vtkm::cont::make_ArrayHandleTransform(array, functor, invFunctor);
}
};
template <typename AH, typename Functor, typename InvFunctor>
struct Serialization<vtkm::cont::ArrayHandle<
typename vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>::ValueType,
vtkm::cont::internal::StorageTagTransform<AH, Functor, InvFunctor>>>
: Serialization<vtkm::cont::ArrayHandleTransform<AH, Functor, InvFunctor>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleTransform_h

65
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -62,4 +62,69 @@ public:
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <>
struct TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
static VTKM_CONT const std::string Get() { return "AH_UniformPointCoordinates"; }
};
template <>
struct TypeString<vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault, 3>,
vtkm::cont::StorageTagImplicit<vtkm::internal::ArrayPortalUniformPointCoordinates>>>
: TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
};
}
} // vtkm::cont
namespace diy
{
template <>
struct Serialization<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
private:
using Type = vtkm::cont::ArrayHandleUniformPointCoordinates;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
diy::save(bb, portal.GetDimensions());
diy::save(bb, portal.GetOrigin());
diy::save(bb, portal.GetSpacing());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
vtkm::Id3 dims;
typename BaseType::ValueType origin, spacing;
diy::load(bb, dims);
diy::load(bb, origin);
diy::load(bb, spacing);
obj = vtkm::cont::ArrayHandleUniformPointCoordinates(dims, origin, spacing);
}
};
template <>
struct Serialization<vtkm::cont::ArrayHandle<
vtkm::Vec<vtkm::FloatDefault, 3>,
vtkm::cont::StorageTagImplicit<vtkm::internal::ArrayPortalUniformPointCoordinates>>>
: Serialization<vtkm::cont::ArrayHandleUniformPointCoordinates>
{
};
} // diy
#endif //vtk_+m_cont_ArrayHandleUniformPointCoordinates_h

102
vtkm/cont/ArrayHandleVirtualCoordinates.h
View File

@ -21,6 +21,7 @@
#define vtk_m_cont_ArrayHandleVirtualCoordinates_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCartesianProduct.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/cont/VirtualObjectHandle.h>
@ -608,4 +609,105 @@ VTKM_EXPLICITLY_INSTANTIATE_TRANSFER(vtkm::cont::internal::CoordinatesPortal<
#endif // VTKM_CUDA
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <>
struct TypeString<vtkm::cont::ArrayHandleVirtualCoordinates>
{
static VTKM_CONT const std::string Get() { return "AH_VirtualCoordinates"; }
};
template <>
struct TypeString<vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>,
vtkm::cont::internal::StorageTagVirtualCoordinates>>
: TypeString<vtkm::cont::ArrayHandleVirtualCoordinates>
{
};
}
} // vtkm::cont
namespace diy
{
template <>
struct Serialization<vtkm::cont::ArrayHandleVirtualCoordinates>
{
private:
using Type = vtkm::cont::ArrayHandleVirtualCoordinates;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
using BasicCoordsType = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>;
using RectilinearCoordsArrayType =
vtkm::cont::ArrayHandleCartesianProduct<vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
vtkm::cont::ArrayHandle<vtkm::FloatDefault>>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
const auto& virtArray = static_cast<const vtkm::cont::ArrayHandleVirtualCoordinates&>(obj);
if (virtArray.IsType<vtkm::cont::ArrayHandleUniformPointCoordinates>())
{
auto array = virtArray.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
diy::save(bb, vtkm::cont::TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>::Get());
diy::save(bb, array);
}
else if (virtArray.IsType<RectilinearCoordsArrayType>())
{
auto array = virtArray.Cast<RectilinearCoordsArrayType>();
diy::save(bb, vtkm::cont::TypeString<RectilinearCoordsArrayType>::Get());
diy::save(bb, array);
}
else
{
diy::save(bb, vtkm::cont::TypeString<BasicCoordsType>::Get());
vtkm::cont::internal::ArrayHandleDefaultSerialization(bb, virtArray);
}
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
std::string typeString;
diy::load(bb, typeString);
if (typeString == vtkm::cont::TypeString<vtkm::cont::ArrayHandleUniformPointCoordinates>::Get())
{
vtkm::cont::ArrayHandleUniformPointCoordinates array;
diy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<RectilinearCoordsArrayType>::Get())
{
RectilinearCoordsArrayType array;
diy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else if (typeString == vtkm::cont::TypeString<BasicCoordsType>::Get())
{
BasicCoordsType array;
diy::load(bb, array);
obj = vtkm::cont::ArrayHandleVirtualCoordinates(array);
}
else
{
throw vtkm::cont::ErrorBadType(
"Error deserializing ArrayHandleVirtualCoordinates. TypeString: " + typeString);
}
}
};
template <>
struct Serialization<vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>,
vtkm::cont::internal::StorageTagVirtualCoordinates>>
: Serialization<vtkm::cont::ArrayHandleVirtualCoordinates>
{
};
} // diy
#endif // vtk_m_cont_ArrayHandleVirtualCoordinates_h

92
vtkm/cont/ArrayHandleZip.h
View File

@ -130,14 +130,16 @@ struct ArrayHandleZipTraits
using Superclass = vtkm::cont::ArrayHandle<ValueType, Tag>;
};
template <typename T, typename FirstHandleType, typename SecondHandleType>
class Storage<T, StorageTagZip<FirstHandleType, SecondHandleType>>
template <typename FirstHandleType, typename SecondHandleType>
class Storage<vtkm::Pair<typename FirstHandleType::ValueType, typename SecondHandleType::ValueType>,
StorageTagZip<FirstHandleType, SecondHandleType>>
{
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
public:
using ValueType = T;
using ValueType =
vtkm::Pair<typename FirstHandleType::ValueType, typename SecondHandleType::ValueType>;
using PortalType = vtkm::exec::internal::ArrayPortalZip<ValueType,
typename FirstHandleType::PortalControl,
@ -213,15 +215,21 @@ private:
SecondHandleType SecondArray;
};
template <typename T, typename FirstHandleType, typename SecondHandleType, typename Device>
class ArrayTransfer<T, StorageTagZip<FirstHandleType, SecondHandleType>, Device>
template <typename FirstHandleType, typename SecondHandleType, typename Device>
class ArrayTransfer<
vtkm::Pair<typename FirstHandleType::ValueType, typename SecondHandleType::ValueType>,
StorageTagZip<FirstHandleType, SecondHandleType>,
Device>
{
public:
using ValueType =
vtkm::Pair<typename FirstHandleType::ValueType, typename SecondHandleType::ValueType>;
private:
using StorageTag = StorageTagZip<FirstHandleType, SecondHandleType>;
using StorageType = vtkm::cont::internal::Storage<T, StorageTag>;
using StorageType = vtkm::cont::internal::Storage<ValueType, StorageTag>;
public:
using ValueType = T;
using PortalControl = typename StorageType::PortalType;
using PortalConstControl = typename StorageType::PortalConstType;
@ -344,4 +352,72 @@ VTKM_CONT vtkm::cont::ArrayHandleZip<FirstHandleType, SecondHandleType> make_Arr
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace vtkm
{
namespace cont
{
template <typename AH1, typename AH2>
struct TypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"AH_Zip<" + TypeString<AH1>::Get() + "," + TypeString<AH2>::Get() + ">";
return name;
}
};
template <typename AH1, typename AH2>
struct TypeString<
vtkm::cont::ArrayHandle<vtkm::Pair<typename AH1::ValueType, typename AH2::ValueType>,
vtkm::cont::internal::StorageTagZip<AH1, AH2>>>
: TypeString<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
};
}
} // namespace vtkm::cont
namespace diy
{
template <typename AH1, typename AH2>
struct Serialization<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
private:
using Type = typename vtkm::cont::ArrayHandleZip<AH1, AH2>;
using BaseType = vtkm::cont::ArrayHandle<typename Type::ValueType, typename Type::StorageTag>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto storage = obj.GetStorage();
diy::save(bb, storage.GetFirstArray());
diy::save(bb, storage.GetSecondArray());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)
{
AH1 a1;
AH2 a2;
diy::load(bb, a1);
diy::load(bb, a2);
obj = vtkm::cont::make_ArrayHandleZip(a1, a2);
}
};
template <typename AH1, typename AH2>
struct Serialization<
vtkm::cont::ArrayHandle<vtkm::Pair<typename AH1::ValueType, typename AH2::ValueType>,
vtkm::cont::internal::StorageTagZip<AH1, AH2>>>
: Serialization<vtkm::cont::ArrayHandleZip<AH1, AH2>>
{
};
} // diy
#endif //vtk_m_cont_ArrayHandleZip_h

3
vtkm/cont/CMakeLists.txt
View File

@ -94,12 +94,14 @@ set(headers
PointLocatorUniformGrid.h
RuntimeDeviceInformation.h
RuntimeDeviceTracker.h
Serialization.h
Storage.h
StorageBasic.h
StorageImplicit.h
StorageListTag.h
Timer.h
TryExecute.h
TypeString.h
VirtualObjectHandle.h
)
@ -161,7 +163,6 @@ vtkm_library( NAME vtkm_cont
)
add_subdirectory(internal)
add_subdirectory(arg)
add_subdirectory(diy)
add_subdirectory(serial)
add_subdirectory(tbb)
add_subdirectory(openmp)

80
vtkm/cont/DynamicArrayHandle.h
View File

@ -491,4 +491,84 @@ struct DynamicTransformTraits<vtkm::cont::DynamicArrayHandleBase<TypeList, Stora
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
namespace diy
{
namespace internal
{
struct DynamicArrayHandleSerializeFunctor
{
template <typename ArrayHandleType>
void operator()(const ArrayHandleType& ah, BinaryBuffer& bb) const
{
diy::save(bb, vtkm::cont::TypeString<ArrayHandleType>::Get());
diy::save(bb, ah);
}
};
template <typename TypeList, typename StorageList>
struct DynamicArrayHandleDeserializeFunctor
{
template <typename T, typename S>
void operator()(brigand::list<T, S>,
vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& dh,
const std::string& typeString,
bool& success,
BinaryBuffer& bb) const
{
using ArrayHandleType = vtkm::cont::ArrayHandle<T, S>;
if (!success && (typeString == vtkm::cont::TypeString<ArrayHandleType>::Get()))
{
ArrayHandleType ah;
diy::load(bb, ah);
dh = vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>(ah);
success = true;
}
}
};
} // internal
template <typename TypeList, typename StorageList>
struct Serialization<vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>>
{
private:
using Type = vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj)
{
obj.CastAndCall(internal::DynamicArrayHandleSerializeFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
using CrossProduct = vtkm::cont::ListTagDynamicTypes<TypeList, StorageList>;
std::string typeString;
diy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(internal::DynamicArrayHandleDeserializeFunctor<TypeList, StorageList>{},
CrossProduct{},
obj,
typeString,
success,
bb);
if (!success)
{
throw vtkm::cont::ErrorBadType(
"Error deserializing DynamicArrayHandle. Message TypeString: " + typeString);
}
}
};
} // diy
#endif //vtk_m_cont_DynamicArrayHandle_h

28
vtkm/cont/diy/Serialization.h → vtkm/cont/Serialization.h
View File

@ -17,11 +17,10 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_diy_Serialization_h
#define vtk_m_cont_diy_Serialization_h
#ifndef vtk_m_cont_Serialization_h
#define vtk_m_cont_Serialization_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/internal/ExportMacros.h>
#include <vtkm/cont/TypeString.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
@ -29,23 +28,4 @@ VTKM_THIRDPARTY_PRE_INCLUDE
#include VTKM_DIY(diy/serialization.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
namespace diy
{
/// This provides specializations to extend DIY's serialization code to
/// load/save vtkm::cont::ArrayHandle instances.
template <typename T, typename StorageTag>
struct Serialization<vtkm::cont::ArrayHandle<T, StorageTag>>
{
VTKM_CONT
static void save(BinaryBuffer& bb, const vtkm::cont::ArrayHandle<T, StorageTag>& indata);
VTKM_CONT
static void load(BinaryBuffer& bb, vtkm::cont::ArrayHandle<T, StorageTag>& outdata);
};
} // namespace diy
#include <vtkm/cont/diy/Serialization.hxx>
#endif
#endif // vtk_m_cont_Serialization_h

188
vtkm/cont/TypeString.h Normal file
View File

@ -0,0 +1,188 @@
//============================================================================
// 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.
//
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_TypeString_h
#define vtk_m_cont_TypeString_h
#include <vtkm/Types.h>
#include <string>
namespace vtkm
{
namespace cont
{
/// \brief A traits class that gives a unique name for a type. This class
/// should be specialized for every type that has to be serialized by diy.
template <typename T>
struct TypeString
#ifdef VTKM_DOXYGEN_ONLY
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "TypeName";
return name;
}
}
#endif
;
namespace internal
{
template <typename T, typename... Ts>
std::string GetVariadicTypeString(const T&, const Ts&... ts)
{
return TypeString<T>::Get() + "," + GetVariadicTypeString(ts...);
}
template <typename T>
std::string GetVariadicTypeString(const T&)
{
return TypeString<T>::Get();
}
} // internal
template <>
struct TypeString<vtkm::Int8>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "I8";
return name;
}
};
template <>
struct TypeString<vtkm::UInt8>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "U8";
return name;
}
};
template <>
struct TypeString<vtkm::Int16>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "I16";
return name;
}
};
template <>
struct TypeString<vtkm::UInt16>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "U16";
return name;
}
};
template <>
struct TypeString<vtkm::Int32>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "I32";
return name;
}
};
template <>
struct TypeString<vtkm::UInt32>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "U32";
return name;
}
};
template <>
struct TypeString<vtkm::Int64>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "I64";
return name;
}
};
template <>
struct TypeString<vtkm::UInt64>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "U64";
return name;
}
};
template <>
struct TypeString<vtkm::Float32>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "F32";
return name;
}
};
template <>
struct TypeString<vtkm::Float64>
{
static VTKM_CONT const std::string& Get()
{
static std::string name = "F64";
return name;
}
};
template <typename T, vtkm::IdComponent NumComponents>
struct TypeString<vtkm::Vec<T, NumComponents>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"V<" + TypeString<T>::Get() + "," + std::to_string(NumComponents) + ">";
return name;
}
};
template <typename T1, typename T2>
struct TypeString<vtkm::Pair<T1, T2>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"vtkm::Pair<" + TypeString<T1>::Get() + "," + TypeString<T2>::Get() + ">";
return name;
}
};
}
} // vtkm::cont
#endif // vtk_m_cont_TypeString_h

27
vtkm/cont/diy/CMakeLists.txt
View File

@ -1,27 +0,0 @@
##============================================================================
## 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.
##
## Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
## Copyright 2014 UT-Battelle, LLC.
## Copyright 2014 Los Alamos National Security.
##
## Under the terms of Contract DE-NA0003525 with NTESS,
## the U.S. Government retains certain rights in this software.
##
## Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
## Laboratory (LANL), the U.S. Government retains certain rights in
## this software.
##============================================================================
set(headers
Serialization.h)
set(header_template_sources
Serialization.hxx)
vtkm_declare_headers(${headers}
EXCLUDE_FROM_TESTING ${header_template_sources})

59
vtkm/cont/diy/Serialization.hxx
View File

@ -1,59 +0,0 @@
//============================================================================
// 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.
//
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/cont/ArrayPortalToIterators.h>
namespace diy
{
template <typename T, typename S>
inline VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T, S>>::save(
BinaryBuffer& bb,
const vtkm::cont::ArrayHandle<T, S>& indata)
{
const vtkm::Id numValues = indata.GetNumberOfValues();
diy::Serialization<vtkm::Id>::save(bb, numValues);
auto const_portal = indata.GetPortalConstControl();
for (vtkm::Id index = 0; index < numValues; ++index)
{
diy::Serialization<T>::save(bb, const_portal.Get(index));
}
}
template <typename T, typename S>
inline VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T, S>>::load(
BinaryBuffer& bb,
vtkm::cont::ArrayHandle<T, S>& outdata)
{
vtkm::Id numValues;
diy::Serialization<vtkm::Id>::load(bb, numValues);
outdata.Allocate(numValues);
T val;
auto portal = outdata.GetPortalControl();
for (vtkm::Id index = 0; index < numValues; ++index)
{
diy::Serialization<T>::load(bb, val);
portal.Set(index, val);
}
}
}

5
vtkm/cont/testing/CMakeLists.txt
View File

@ -33,6 +33,7 @@ set(headers
TestingFancyArrayHandles.h
TestingImplicitFunction.h
TestingPointLocatorUniformGrid.h
TestingSerialization.h
TestingVirtualObjectHandle.h
)
@ -86,5 +87,7 @@ vtkm_unit_tests(SOURCES ${unit_tests})
# add distributed tests i.e. test to run with MPI
# if MPI is enabled.
set(mpi_unit_tests
UnitTestFieldRangeGlobalCompute.cxx)
UnitTestFieldRangeGlobalCompute.cxx
UnitTestSerializationArrayHandle.cxx
)
vtkm_unit_tests(MPI SOURCES ${mpi_unit_tests})

263
vtkm/cont/testing/TestingSerialization.h Normal file
View File

@ -0,0 +1,263 @@
//============================================================================
// 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.
//
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_testing_TestingSerialization_h
#define vtk_m_cont_testing_TestingSerialization_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/testing/Testing.h>
// clang-format off
VTKM_THIRDPARTY_PRE_INCLUDE
#include <vtkm/thirdparty/diy/Configure.h>
#include VTKM_DIY(diy/master.hpp)
#include VTKM_DIY(diy/mpi.hpp)
VTKM_THIRDPARTY_POST_INCLUDE
// clang-format on
#include <random>
namespace vtkm
{
namespace cont
{
namespace testing
{
namespace serialization
{
//-----------------------------------------------------------------------------
static std::default_random_engine generator;
template <typename T>
class UniformRandomValueGenerator
{
private:
using DistributionType = typename std::conditional<std::is_integral<T>::value,
std::uniform_int_distribution<vtkm::Id>,
std::uniform_real_distribution<T>>::type;
public:
UniformRandomValueGenerator()
: Distribution(-127, 127)
{
}
UniformRandomValueGenerator(T min, T max)
: Distribution(static_cast<typename DistributionType::result_type>(min),
static_cast<typename DistributionType::result_type>(max))
{
}
T operator()() { return static_cast<T>(this->Distribution(generator)); }
private:
DistributionType Distribution;
};
template <typename T, typename Tag = typename vtkm::VecTraits<T>::HasMultipleComponents>
struct BaseScalarType;
template <typename T>
struct BaseScalarType<T, vtkm::VecTraitsTagSingleComponent>
{
using Type = T;
};
template <typename T>
struct BaseScalarType<T, vtkm::VecTraitsTagMultipleComponents>
{
using Type = typename BaseScalarType<typename vtkm::VecTraits<T>::ComponentType>::Type;
};
template <typename T>
using BaseScalarType_t = typename BaseScalarType<T>::Type;
template <typename T>
struct RandomValue_
{
static T Make(UniformRandomValueGenerator<T>& rangen) { return static_cast<T>(rangen()); }
};
template <typename T, vtkm::IdComponent NumComponents>
struct RandomValue_<vtkm::Vec<T, NumComponents>>
{
using VecType = vtkm::Vec<T, NumComponents>;
static VecType Make(UniformRandomValueGenerator<BaseScalarType_t<T>>& rangen)
{
VecType val{};
for (vtkm::IdComponent i = 0; i < NumComponents; ++i)
{
val[i] = RandomValue_<T>::Make(rangen);
}
return val;
}
};
template <typename T>
struct RandomValue : RandomValue_<T>
{
using RandomValue_<T>::Make;
static T Make(BaseScalarType_t<T> min, BaseScalarType_t<T> max)
{
auto rangen = UniformRandomValueGenerator<BaseScalarType_t<T>>(min, max);
return Make(rangen);
}
static T Make()
{
auto rangen = UniformRandomValueGenerator<BaseScalarType_t<T>>();
return Make(rangen);
}
};
template <typename T>
struct RandomArrayHandle
{
static vtkm::cont::ArrayHandle<T> Make(UniformRandomValueGenerator<BaseScalarType_t<T>>& rangen,
vtkm::Id length)
{
vtkm::cont::ArrayHandle<T> a;
a.Allocate(length);
for (vtkm::Id i = 0; i < length; ++i)
{
a.GetPortalControl().Set(i, RandomValue<T>::Make(rangen));
}
return a;
}
static vtkm::cont::ArrayHandle<T> Make(vtkm::Id length,
BaseScalarType_t<T> min,
BaseScalarType_t<T> max)
{
auto rangen = UniformRandomValueGenerator<BaseScalarType_t<T>>(min, max);
return Make(rangen, length);
}
static vtkm::cont::ArrayHandle<T> Make(vtkm::Id length)
{
auto rangen = UniformRandomValueGenerator<BaseScalarType_t<T>>();
return Make(rangen, length);
}
};
//-----------------------------------------------------------------------------
template <typename T>
struct Block
{
T send;
T received;
};
template <typename T, typename TestEqualFunctor>
void TestSerialization(const T& obj, const TestEqualFunctor& test)
{
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
diy::Master master(comm);
auto nblocks = comm.size();
diy::RoundRobinAssigner assigner(comm.size(), nblocks);
std::vector<int> gids;
assigner.local_gids(comm.rank(), gids);
VTKM_ASSERT(gids.size() == 1);
auto gid = gids[0];
Block<T> block;
block.send = obj;
diy::Link* link = new diy::Link;
diy::BlockID neighbor;
// send neighbor
neighbor.gid = (gid < (nblocks - 1)) ? (gid + 1) : 0;
neighbor.proc = assigner.rank(neighbor.gid);
link->add_neighbor(neighbor);
// recv neighbor
neighbor.gid = (gid > 0) ? (gid - 1) : (nblocks - 1);
neighbor.proc = assigner.rank(neighbor.gid);
link->add_neighbor(neighbor);
master.add(gid, &block, link);
// compute, exchange, compute
master.foreach ([](Block<T>* b, const diy::Master::ProxyWithLink& cp) {
cp.enqueue(cp.link()->target(0), b->send);
});
master.exchange();
master.foreach ([](Block<T>* b, const diy::Master::ProxyWithLink& cp) {
cp.dequeue(cp.link()->target(1).gid, b->received);
});
comm.barrier();
test(block.send, block.received);
}
//-----------------------------------------------------------------------------
struct TestEqualArrayHandle
{
public:
template <typename T, typename S>
void operator()(const vtkm::cont::ArrayHandle<T, S>& a1,
const vtkm::cont::ArrayHandle<T, S>& a2) const try
{
VTKM_TEST_ASSERT(a1.GetNumberOfValues() == a2.GetNumberOfValues(),
"vtkm::cont::ArrayHandle sizes don't match");
auto portal1 = a1.GetPortalConstControl();
auto portal2 = a2.GetPortalConstControl();
for (vtkm::Id i = 0; i < portal1.GetNumberOfValues(); ++i)
{
VTKM_TEST_ASSERT(test_equal(portal1.Get(i), portal2.Get(i)),
"vtkm::cont::ArrayHandle values don't match");
}
}
catch (...)
{
vtkm::cont::printSummary_ArrayHandle(a1, std::cout, true);
vtkm::cont::printSummary_ArrayHandle(a2, std::cout, true);
throw;
}
template <typename TypeList, typename StorageList>
void operator()(const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& a1,
const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& a2) const
{
a1.CastAndCall(*this, a2);
}
template <typename T, typename S, typename TypeList, typename StorageList>
void operator()(const vtkm::cont::ArrayHandle<T, S>& a,
const vtkm::cont::DynamicArrayHandleBase<TypeList, StorageList>& da) const
{
this->operator()(a, da.template Cast<vtkm::cont::ArrayHandle<T, S>>());
}
};
}
}
}
} // vtkm::cont::testing::serialization
#endif // vtk_m_cont_testing_TestingSerialization_h

550
vtkm/cont/testing/UnitTestSerializationArrayHandle.cxx Normal file
View File

@ -0,0 +1,550 @@
//============================================================================
// 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.
//
// Copyright 2014 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014 Los Alamos National Security.
//
// Under the terms of Contract DE-NA0003525 with NTESS,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCartesianProduct.h>
#include <vtkm/cont/ArrayHandleCast.h>
#include <vtkm/cont/ArrayHandleCompositeVector.h>
#include <vtkm/cont/ArrayHandleConcatenate.h>
#include <vtkm/cont/ArrayHandleConstant.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/ArrayHandleExtractComponent.h>
#include <vtkm/cont/ArrayHandleGroupVec.h>
#include <vtkm/cont/ArrayHandleGroupVecVariable.h>
#include <vtkm/cont/ArrayHandleImplicit.h>
#include <vtkm/cont/ArrayHandleIndex.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleReverse.h>
#include <vtkm/cont/ArrayHandleSwizzle.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/ArrayHandleVirtualCoordinates.h>
#include <vtkm/cont/ArrayHandleZip.h>
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/testing/TestingSerialization.h>
#include <vtkm/VecTraits.h>
#include <ctime>
#include <type_traits>
#include <vector>
using namespace vtkm::cont::testing::serialization;
namespace
{
//-----------------------------------------------------------------------------
template <typename T>
inline void RunTest(const T& obj)
{
TestSerialization(obj, TestEqualArrayHandle{});
}
//-----------------------------------------------------------------------------
constexpr vtkm::Id ArraySize = 10;
using TestTypesList =
vtkm::ListTagBase<vtkm::Int8, vtkm::Id, vtkm::FloatDefault, vtkm::Vec<vtkm::FloatDefault, 3>>;
using TestStorageList = vtkm::ListTagBase<vtkm::cont::StorageTagBasic>;
template <typename T, typename S>
inline vtkm::cont::DynamicArrayHandleBase<vtkm::ListTagAppendUnique<TestTypesList, T>,
vtkm::ListTagAppendUnique<TestStorageList, S>>
MakeTestDynamicArrayHandle(const vtkm::cont::ArrayHandle<T, S>& array)
{
return array;
}
struct TestArrayHandleBasic
{
template <typename T>
void operator()(T) const
{
auto array = RandomArrayHandle<T>::Make(ArraySize);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleCartesianProduct
{
template <typename T>
void operator()(T) const
{
auto array =
vtkm::cont::make_ArrayHandleCartesianProduct(RandomArrayHandle<T>::Make(ArraySize),
RandomArrayHandle<T>::Make(ArraySize),
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleCast
{
template <typename T>
void operator()(T) const
{
auto array =
vtkm::cont::make_ArrayHandleCast(RandomArrayHandle<vtkm::Int8>::Make(ArraySize), T{});
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleCompositeVector
{
template <typename T>
void operator()(T) const
{
auto array = vtkm::cont::make_ArrayHandleCompositeVector(RandomArrayHandle<T>::Make(ArraySize),
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleConcatenate
{
template <typename T>
void operator()(T) const
{
auto array = vtkm::cont::make_ArrayHandleConcatenate(RandomArrayHandle<T>::Make(ArraySize),
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleConstant
{
template <typename T>
void operator()(T) const
{
T cval = RandomValue<T>::Make();
auto array = vtkm::cont::make_ArrayHandleConstant(cval, ArraySize);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleCounting
{
template <typename T>
void operator()(T) const
{
T start = RandomValue<T>::Make();
T step = RandomValue<T>::Make(0, 5);
auto array = vtkm::cont::make_ArrayHandleCounting(start, step, ArraySize);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleExtractComponent
{
template <typename T>
void operator()(T) const
{
auto numComps = vtkm::VecTraits<T>::NUM_COMPONENTS;
auto array = vtkm::cont::make_ArrayHandleExtractComponent(
RandomArrayHandle<T>::Make(ArraySize), RandomValue<vtkm::IdComponent>::Make(0, numComps - 1));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleGroupVec
{
template <typename T>
void operator()(T) const
{
auto numComps = RandomValue<vtkm::IdComponent>::Make(2, 4);
auto flat = RandomArrayHandle<T>::Make(ArraySize * numComps);
switch (numComps)
{
case 3:
{
auto array = vtkm::cont::make_ArrayHandleGroupVec<3>(flat);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
break;
}
case 4:
{
auto array = vtkm::cont::make_ArrayHandleGroupVec<4>(flat);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
break;
}
default:
{
auto array = vtkm::cont::make_ArrayHandleGroupVec<2>(flat);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
break;
}
}
}
};
struct TestArrayHandleGroupVecVariable
{
template <typename T>
void operator()(T) const
{
auto rangen = UniformRandomValueGenerator<vtkm::IdComponent>(1, 4);
vtkm::Id size = 0;
std::vector<vtkm::Id> comps(ArraySize);
std::generate(comps.begin(), comps.end(), [&size, &rangen]() {
auto offset = size;
size += rangen();
return offset;
});
auto array = vtkm::cont::make_ArrayHandleGroupVecVariable(RandomArrayHandle<T>::Make(size),
vtkm::cont::make_ArrayHandle(comps));
RunTest(array);
// cannot make a DynamicArrayHandle containing ArrayHandleGroupVecVariable
// because of the variable number of components of its values.
// RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleImplicit
{
template <typename T>
struct ImplicitFunctor
{
ImplicitFunctor() = default;
explicit ImplicitFunctor(const T& factor)
: Factor(factor)
{
}
VTKM_EXEC_CONT T operator()(vtkm::Id index) const
{
return static_cast<T>(this->Factor *
static_cast<typename vtkm::VecTraits<T>::ComponentType>(index));
}
T Factor;
};
template <typename T>
void operator()(T) const
{
ImplicitFunctor<T> functor(RandomValue<T>::Make(2, 9));
auto array = vtkm::cont::make_ArrayHandleImplicit(functor, ArraySize);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
void TestArrayHandleIndex()
{
auto size = RandomValue<vtkm::Id>::Make(2, 10);
auto array = vtkm::cont::ArrayHandleIndex(size);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
struct TestArrayHandlePermutation
{
template <typename T>
void operator()(T) const
{
std::uniform_int_distribution<vtkm::Id> distribution(0, ArraySize - 1);
std::vector<vtkm::Id> inds(ArraySize);
std::generate(inds.begin(), inds.end(), [&distribution]() { return distribution(generator); });
auto array = vtkm::cont::make_ArrayHandlePermutation(
RandomArrayHandle<vtkm::Id>::Make(ArraySize, 0, ArraySize - 1),
RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleReverse
{
template <typename T>
void operator()(T) const
{
auto array = vtkm::cont::make_ArrayHandleReverse(RandomArrayHandle<T>::Make(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
struct TestArrayHandleSwizzle
{
template <typename T>
void operator()(T) const
{
static const vtkm::Vec<vtkm::IdComponent, 2> map2s[6] = { { 0, 1 }, { 0, 2 }, { 1, 0 },
{ 1, 2 }, { 2, 0 }, { 2, 1 } };
static const vtkm::Vec<vtkm::IdComponent, 3> map3s[6] = {
{ 0, 1, 2 }, { 0, 2, 1 }, { 1, 0, 2 }, { 1, 2, 0 }, { 2, 0, 1 }, { 2, 1, 0 }
};
auto numOutComps = RandomValue<vtkm::IdComponent>::Make(2, 3);
switch (numOutComps)
{
case 2:
{
auto array = make_ArrayHandleSwizzle(RandomArrayHandle<vtkm::Vec<T, 3>>::Make(ArraySize),
map2s[RandomValue<int>::Make(0, 5)]);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
break;
}
case 3:
default:
{
auto array = make_ArrayHandleSwizzle(RandomArrayHandle<vtkm::Vec<T, 3>>::Make(ArraySize),
map3s[RandomValue<int>::Make(0, 5)]);
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
break;
}
}
}
};
struct TestArrayHandleTransform
{
struct TransformFunctor
{
template <typename T>
VTKM_EXEC_CONT T operator()(const T& in) const
{
return static_cast<T>(in * T{ 2 });
}
};
struct InverseTransformFunctor
{
template <typename T>
VTKM_EXEC_CONT T operator()(const T& in) const
{
return in / T{ 2 };
}
};
template <typename T>
void TestType1() const
{
auto array = vtkm::cont::make_ArrayHandleTransform(RandomArrayHandle<T>::Make(ArraySize),
TransformFunctor{});
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
template <typename T>
void TestType2() const
{
auto array = vtkm::cont::make_ArrayHandleTransform(
RandomArrayHandle<T>::Make(ArraySize), TransformFunctor{}, InverseTransformFunctor{});
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
template <typename T>
void operator()(T) const
{
this->TestType1<T>();
this->TestType2<T>();
}
};
vtkm::cont::ArrayHandleUniformPointCoordinates MakeRandomArrayHandleUniformPointCoordinates()
{
auto dimensions = RandomValue<vtkm::Id3>::Make(1, 3);
auto origin = RandomValue<vtkm::Vec<vtkm::FloatDefault, 3>>::Make();
auto spacing = RandomValue<vtkm::Vec<vtkm::FloatDefault, 3>>::Make(0.1f, 10.0f);
return vtkm::cont::ArrayHandleUniformPointCoordinates(dimensions, origin, spacing);
}
void TestArrayHandleUniformPointCoordinates()
{
auto array = MakeRandomArrayHandleUniformPointCoordinates();
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
void TestArrayHandleVirtualCoordinates()
{
int type = RandomValue<int>::Make(0, 2);
vtkm::cont::ArrayHandleVirtualCoordinates array;
switch (type)
{
case 0:
array =
vtkm::cont::ArrayHandleVirtualCoordinates(MakeRandomArrayHandleUniformPointCoordinates());
break;
case 1:
array =
vtkm::cont::ArrayHandleVirtualCoordinates(vtkm::cont::make_ArrayHandleCartesianProduct(
RandomArrayHandle<vtkm::FloatDefault>::Make(ArraySize),
RandomArrayHandle<vtkm::FloatDefault>::Make(ArraySize),
RandomArrayHandle<vtkm::FloatDefault>::Make(ArraySize)));
break;
default:
array = vtkm::cont::ArrayHandleVirtualCoordinates(
RandomArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>>::Make(ArraySize));
break;
}
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
struct TestArrayHandleZip
{
template <typename T>
void operator()(T) const
{
auto array = vtkm::cont::make_ArrayHandleZip(RandomArrayHandle<T>::Make(ArraySize),
vtkm::cont::ArrayHandleIndex(ArraySize));
RunTest(array);
RunTest(MakeTestDynamicArrayHandle(array));
}
};
//-----------------------------------------------------------------------------
void TestArrayHandleSerialization()
{
std::cout << "Testing ArrayHandleBasic\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleBasic(), TestTypesList());
std::cout << "Testing ArrayHandleCartesianProduct\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleCartesianProduct(), TestTypesList());
std::cout << "Testing TestArrayHandleCast\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleCast(), TestTypesList());
std::cout << "Testing ArrayHandleCompositeVector\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleCompositeVector(), TestTypesList());
std::cout << "Testing ArrayHandleConcatenate\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleConcatenate(), TestTypesList());
std::cout << "Testing ArrayHandleConstant\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleConstant(), TestTypesList());
std::cout << "Testing ArrayHandleCounting\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleCounting(), TestTypesList());
std::cout << "Testing ArrayHandleExtractComponent\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleExtractComponent(), TestTypesList());
std::cout << "Testing ArrayHandleGroupVec\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleGroupVec(), TestTypesList());
std::cout << "Testing ArrayHandleGroupVecVariable\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleGroupVecVariable(), TestTypesList());
std::cout << "Testing ArrayHandleImplicit\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleImplicit(), TestTypesList());
std::cout << "Testing ArrayHandleIndex\n";
TestArrayHandleIndex();
std::cout << "Testing ArrayHandlePermutation\n";
vtkm::testing::Testing::TryTypes(TestArrayHandlePermutation(), TestTypesList());
std::cout << "Testing ArrayHandleReverse\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleReverse(), TestTypesList());
std::cout << "Testing ArrayHandleSwizzle\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleSwizzle(), TestTypesList());
std::cout << "Testing ArrayHandleTransform\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleTransform(), TestTypesList());
std::cout << "Testing ArrayHandleUniformPointCoordinates\n";
TestArrayHandleUniformPointCoordinates();
std::cout << "Testing ArrayHandleVirtualCoordinates\n";
TestArrayHandleVirtualCoordinates();
std::cout << "Testing ArrayHandleZip\n";
vtkm::testing::Testing::TryTypes(TestArrayHandleZip(), TestTypesList());
}
} // anonymous namespace
//-----------------------------------------------------------------------------
int UnitTestSerializationArrayHandle(int, char* [])
{
auto comm = vtkm::cont::EnvironmentTracker::GetCommunicator();
decltype(generator)::result_type seed = 0;
if (comm.rank() == 0)
{
seed = static_cast<decltype(seed)>(std::time(nullptr));
std::cout << "using seed: " << seed << "\n";
}
diy::mpi::broadcast(comm, seed, 0);
generator.seed(seed);
return vtkm::cont::testing::Testing::Run(TestArrayHandleSerialization);
}
//-----------------------------------------------------------------------------
namespace vtkm
{
namespace cont
{
template <typename T>
struct TypeString<TestArrayHandleImplicit::ImplicitFunctor<T>>
{
static VTKM_CONT const std::string& Get()
{
static std::string name =
"TestArrayHandleImplicit::ImplicitFunctor<" + TypeString<T>::Get() + ">";
return name;
}
};
template <>
struct TypeString<TestArrayHandleTransform::TransformFunctor>
{
static VTKM_CONT const std::string Get() { return "TestArrayHandleTransform::TransformFunctor"; }
};
template <>
struct TypeString<TestArrayHandleTransform::InverseTransformFunctor>
{
static VTKM_CONT const std::string Get()
{
return "TestArrayHandleTransform::InverseTransformFunctor";
}
};
}
} // vtkm::cont

2
vtkm/filter/Histogram.hxx
View File

@ -27,7 +27,7 @@
#include <vtkm/cont/EnvironmentTracker.h>
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/cont/FieldRangeGlobalCompute.h>
#include <vtkm/cont/diy/Serialization.h>
#include <vtkm/cont/Serialization.h>
#include <vtkm/filter/internal/CreateResult.h>
// clang-format off