Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Merge branch 'container-to-storage'

Browse Source
This commit is contained in:
Kenneth Moreland 2014-06-25 11:29:26 -06:00
commit 2f1d910eeb
36 changed files with 713 additions and 752 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
vtkm/cont/ArrayHandle.h
View File

@ -22,9 +22,10 @@
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/Assert.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayHandleExecutionManager.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
#include <vtkm/cont/internal/DeviceAdapterTag.h>
@ -42,18 +43,18 @@ namespace cont {
namespace internal {
/// Checks to see if the given type and container can form a valid array handle
/// (some containers cannot support all types). This check is compatable with
/// the Boost meta-template programming library (MPL). It contains a typedef
/// named type that is either boost::mpl::true_ or boost::mpl::false_. Both of
/// these have a typedef named value with the respective boolean value.
/// Checks to see if the given type and storage can form a valid array handle
/// (some storage objects cannot support all types). This check is compatable
/// with the Boost meta-template programming library (MPL). It contains a
/// typedef named type that is either boost::mpl::true_ or boost::mpl::false_.
/// Both of these have a typedef named value with the respective boolean value.
///
template<typename T, typename ArrayContainerControlTag>
template<typename T, typename StorageTag>
struct IsValidArrayHandle {
typedef typename boost::mpl::not_<
typename boost::is_base_of<
vtkm::cont::internal::UndefinedArrayContainerControl,
vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
vtkm::cont::internal::UndefinedStorage,
vtkm::cont::internal::Storage<T,StorageTag>
>::type
>::type type;
};
@ -83,22 +84,18 @@ struct IsValidArrayHandle {
///
template<
typename T,
typename ArrayContainerControlTag_ = VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
typename StorageTag_ = VTKM_DEFAULT_STORAGE_TAG>
class ArrayHandle
{
private:
typedef vtkm::cont::internal
::ArrayContainerControl<T,ArrayContainerControlTag_>
ArrayContainerControlType;
typedef vtkm::cont::internal
::ArrayHandleExecutionManagerBase<T,ArrayContainerControlTag_>
typedef vtkm::cont::internal::Storage<T,StorageTag_> StorageType;
typedef vtkm::cont::internal::ArrayHandleExecutionManagerBase<T,StorageTag_>
ExecutionManagerType;
public:
typedef T ValueType;
typedef ArrayContainerControlTag_ ArrayContainerControlTag;
typedef typename ArrayContainerControlType::PortalType PortalControl;
typedef typename ArrayContainerControlType::PortalConstType
PortalConstControl;
typedef StorageTag_ StorageTag;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
template <typename DeviceAdapterTag>
struct ExecutionTypes
{
@ -398,11 +395,11 @@ public:
/// initial state of the control array. When this constructor is used, it
/// is assumed that the control array is valid.
///
ArrayHandle(const ArrayContainerControlType &container)
ArrayHandle(const StorageType &storage)
: Internals(new InternalStruct)
{
this->Internals->UserPortalValid = false;
this->Internals->ControlArray = container;
this->Internals->ControlArray = storage;
this->Internals->ControlArrayValid = true;
this->Internals->ExecutionArrayValid = false;
}
@ -413,12 +410,12 @@ public:
PortalConstControl UserPortal;
bool UserPortalValid;
ArrayContainerControlType ControlArray;
StorageType ControlArray;
bool ControlArrayValid;
boost::scoped_ptr<
vtkm::cont::internal::ArrayHandleExecutionManagerBase<
ValueType,ArrayContainerControlTag> > ExecutionArray;
ValueType,StorageTag> > ExecutionArray;
bool ExecutionArrayValid;
};
@ -468,7 +465,7 @@ public:
= const_cast<InternalStruct*>(this->Internals.get());
internals->ExecutionArray.reset(
new vtkm::cont::internal::ArrayHandleExecutionManager<
T, ArrayContainerControlTag, DeviceAdapterTag>);
T, StorageTag, DeviceAdapterTag>);
}
/// Synchronizes the control array with the execution array. If either the
@ -502,55 +499,55 @@ public:
boost::shared_ptr<InternalStruct> Internals;
};
/// A convenience function for creating an ArrayHandle from a standard C
/// array. Unless properly specialized, this only works with container types
/// that use an array portal that accepts a pair of pointers to signify the
/// beginning and end of the array.
/// A convenience function for creating an ArrayHandle from a standard C array.
/// Unless properly specialized, this only works with storage types that use an
/// array portal that accepts a pair of pointers to signify the beginning and
/// end of the array.
///
template<typename T, typename ArrayContainerControlTag>
template<typename T, typename StorageTag>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, ArrayContainerControlTag>
vtkm::cont::ArrayHandle<T, StorageTag>
make_ArrayHandle(const T *array,
vtkm::Id length,
ArrayContainerControlTag)
StorageTag)
{
typedef vtkm::cont::ArrayHandle<T, ArrayContainerControlTag> ArrayHandleType;
typedef vtkm::cont::ArrayHandle<T, StorageTag> ArrayHandleType;
typedef typename ArrayHandleType::PortalConstControl PortalType;
return ArrayHandleType(PortalType(array, array+length));
}
template<typename T>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_STORAGE_TAG>
make_ArrayHandle(const T *array, vtkm::Id length)
{
return make_ArrayHandle(array,
length,
VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG());
VTKM_DEFAULT_STORAGE_TAG());
}
/// A convenience function for creating an ArrayHandle from an std::vector.
/// Unless properly specialized, this only works with container types that use
/// an array portal that accepts a pair of pointers to signify the beginning
/// and end of the array.
/// Unless properly specialized, this only works with storage types that use an
/// array portal that accepts a pair of pointers to signify the beginning and
/// end of the array.
///
template<typename T,
typename Allocator,
typename ArrayContainerControlTag>
typename StorageTag>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, ArrayContainerControlTag>
vtkm::cont::ArrayHandle<T, StorageTag>
make_ArrayHandle(const std::vector<T,Allocator> &array,
ArrayContainerControlTag)
StorageTag)
{
typedef vtkm::cont::ArrayHandle<T, ArrayContainerControlTag> ArrayHandleType;
typedef vtkm::cont::ArrayHandle<T, StorageTag> ArrayHandleType;
typedef typename ArrayHandleType::PortalConstControl PortalType;
return ArrayHandleType(PortalType(&array.front(), &array.back() + 1));
}
template<typename T, typename Allocator>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG>
vtkm::cont::ArrayHandle<T, VTKM_DEFAULT_STORAGE_TAG>
make_ArrayHandle(const std::vector<T,Allocator> &array)
{
return make_ArrayHandle(array, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG());
return make_ArrayHandle(array, VTKM_DEFAULT_STORAGE_TAG());
}
}

197
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -272,28 +272,27 @@ private:
};
template<typename SignatureWithArrays>
struct ArrayContainerControlTagCompositeVector { };
struct StorageTagCompositeVector { };
/// A convenience class that provides a typedef to the appropriate tag for
/// a counting array container.
/// a composite storage.
template<typename SignatureWithArrays>
struct ArrayHandleCompositeVectorTraits
{
typedef vtkm::cont::internal::ArrayContainerControlTagCompositeVector<
SignatureWithArrays> Tag;
typedef vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays>
Tag;
typedef typename vtkm::internal::FunctionInterface<SignatureWithArrays>::ResultType
ValueType;
typedef vtkm::cont::internal::ArrayContainerControl<
ValueType, Tag> ContainerType;
typedef vtkm::cont::internal::Storage<ValueType, Tag> StorageType;
};
// It may seem weird that this specialization throws an exception for
// everything, but that is because all the functionality is handled in the
// ArrayTransfer class.
template<typename SignatureWithArrays>
class ArrayContainerControl<
class Storage<
typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ValueType,
vtkm::cont::internal::ArrayContainerControlTagCompositeVector<SignatureWithArrays> >
vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays> >
{
typedef vtkm::internal::FunctionInterface<SignatureWithArrays>
FunctionInterfaceWithArrays;
@ -306,11 +305,11 @@ public:
typedef typename PortalType::ValueType ValueType;
VTKM_CONT_EXPORT
ArrayContainerControl() : Valid(false) { }
Storage() : Valid(false) { }
VTKM_CONT_EXPORT
ArrayContainerControl(const FunctionInterfaceWithArrays &arrays,
const ComponentMapType &sourceComponents)
Storage(const FunctionInterfaceWithArrays &arrays,
const ComponentMapType &sourceComponents)
: Arrays(arrays), SourceComponents(sourceComponents), Valid(true)
{
arrays.ForEachCont(
@ -347,11 +346,11 @@ public:
void Allocate(vtkm::Id vtkmNotUsed(numberOfValues)) {
throw vtkm::cont::ErrorControlInternal(
"The allocate method for the composite vector control array "
"container should never have been called. The allocate is generally "
"only called by the execution array manager, and the array transfer "
"for the transform container should prevent the execution array "
"manager from being directly used.");
"The allocate method for the composite vector storage should never "
"have been called. The allocate is generally only called by the "
"execution array manager, and the array transfer for the composite "
"storage should prevent the execution array manager from being "
"directly used.");
}
VTKM_CONT_EXPORT
@ -389,13 +388,13 @@ private:
template<typename SignatureWithArrays, typename DeviceAdapterTag>
class ArrayTransfer<
typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ValueType,
vtkm::cont::internal::ArrayContainerControlTagCompositeVector<SignatureWithArrays>,
vtkm::cont::internal::StorageTagCompositeVector<SignatureWithArrays>,
DeviceAdapterTag>
{
VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
typedef typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::ContainerType
ContainerType;
typedef typename ArrayHandleCompositeVectorTraits<SignatureWithArrays>::StorageType
StorageType;
typedef vtkm::internal::FunctionInterface<SignatureWithArrays>
FunctionWithArrays;
@ -409,19 +408,19 @@ public:
ValueType;
// These are not currently fully implemented.
typedef typename ContainerType::PortalType PortalControl;
typedef typename ContainerType::PortalConstType PortalConstControl;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef ArrayPortalCompositeVector<SignatureWithPortals> PortalExecution;
typedef ArrayPortalCompositeVector<SignatureWithPortals> PortalConstExecution;
VTKM_CONT_EXPORT
ArrayTransfer() : ContainerValid(false) { }
ArrayTransfer() : StorageValid(false) { }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
VTKM_ASSERT_CONT(this->ContainerValid);
return this->Container.GetNumberOfValues();
VTKM_ASSERT_CONT(this->StorageValid);
return this->Storage.GetNumberOfValues();
}
VTKM_CONT_EXPORT
@ -433,21 +432,21 @@ public:
}
VTKM_CONT_EXPORT
void LoadDataForInput(const ContainerType &controlArray)
void LoadDataForInput(const StorageType &controlArray)
{
this->Container = controlArray;
this->ContainerValid = true;
this->Storage = controlArray;
this->StorageValid = true;
}
VTKM_CONT_EXPORT
void LoadDataForInPlace(ContainerType &vtkmNotUsed(controlArray))
void LoadDataForInPlace(StorageType &vtkmNotUsed(controlArray))
{
throw vtkm::cont::ErrorControlBadValue(
"Composite vector arrays cannot be used for output or in place.");
}
VTKM_CONT_EXPORT
void AllocateArrayForOutput(ContainerType &vtkmNotUsed(controlArray),
void AllocateArrayForOutput(StorageType &vtkmNotUsed(controlArray),
vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue(
@ -455,7 +454,7 @@ public:
}
VTKM_CONT_EXPORT
void RetrieveOutputData(ContainerType &vtkmNotUsed(controlArray)) const
void RetrieveOutputData(StorageType &vtkmNotUsed(controlArray)) const
{
throw vtkm::cont::ErrorControlBadValue(
"Composite vector arrays cannot be used for output.");
@ -478,22 +477,22 @@ public:
VTKM_CONT_EXPORT
PortalConstExecution GetPortalConstExecution() const
{
VTKM_ASSERT_CONT(this->ContainerValid);
VTKM_ASSERT_CONT(this->StorageValid);
return
PortalConstExecution(
this->Container.GetArrays().StaticTransformCont(
this->Storage.GetArrays().StaticTransformCont(
detail::CompositeVectorArrayToPortalExec<DeviceAdapterTag>()),
this->Container.GetSourceComponents());
this->Storage.GetSourceComponents());
}
VTKM_CONT_EXPORT
void ReleaseResources() {
this->Container.ReleaseResources();
this->Storage.ReleaseResources();
}
private:
bool ContainerValid;
ContainerType Container;
bool StorageValid;
StorageType Storage;
};
} // namespace internal
@ -514,8 +513,8 @@ class ArrayHandleCompositeVector
typename internal::ArrayHandleCompositeVectorTraits<Signature>::ValueType,
typename internal::ArrayHandleCompositeVectorTraits<Signature>::Tag>
{
typedef typename internal::ArrayHandleCompositeVectorTraits<Signature>::ContainerType
ArrayContainerControlType;
typedef typename internal::ArrayHandleCompositeVectorTraits<Signature>::StorageType
StorageType;
typedef typename internal::ArrayPortalCompositeVectorCont<Signature>::ComponentMapType
ComponentMapType;
@ -533,7 +532,7 @@ public:
ArrayHandleCompositeVector(
const vtkm::internal::FunctionInterface<Signature> &arrays,
const ComponentMapType &sourceComponents)
: Superclass(ArrayContainerControlType(arrays, sourceComponents))
: Superclass(StorageType(arrays, sourceComponents))
{ }
/// Template constructors for passing in types. You'll get weird compile
@ -544,7 +543,7 @@ public:
VTKM_CONT_EXPORT
ArrayHandleCompositeVector(const ArrayHandleType1 &array1,
int sourceComponent1)
: Superclass(ArrayContainerControlType(
: Superclass(StorageType(
vtkm::internal::make_FunctionInterface<ValueType>(array1),
ComponentMapType(sourceComponent1)))
{ }
@ -555,7 +554,7 @@ public:
int sourceComponent1,
const ArrayHandleType2 &array2,
int sourceComponent2)
: Superclass(ArrayContainerControlType(
: Superclass(StorageType(
vtkm::internal::make_FunctionInterface<ValueType>(
array1, array2),
ComponentMapType(sourceComponent1,
@ -571,7 +570,7 @@ public:
int sourceComponent2,
const ArrayHandleType3 &array3,
int sourceComponent3)
: Superclass(ArrayContainerControlType(
: Superclass(StorageType(
vtkm::internal::make_FunctionInterface<ValueType>(
array1, array2, array3),
ComponentMapType(sourceComponent1,
@ -591,7 +590,7 @@ public:
int sourceComponent3,
const ArrayHandleType4 &array4,
int sourceComponent4)
: Superclass(ArrayContainerControlType(
: Superclass(StorageType(
vtkm::internal::make_FunctionInterface<ValueType>(
array1, array2, array3, array4),
ComponentMapType(sourceComponent1,
@ -670,95 +669,95 @@ public:
/// Create a composite vector array from other arrays.
///
template<typename ValueType1, typename Container1>
template<typename ValueType1, typename Storage1>
VTKM_CONT_EXPORT
typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1> >::type
vtkm::cont::ArrayHandle<ValueType1,Storage1> >::type
make_ArrayHandleCompositeVector(
const vtkm::cont::ArrayHandle<ValueType1,Container1> &array1,
const vtkm::cont::ArrayHandle<ValueType1,Storage1> &array1,
int sourceComponent1)
{
return typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1> >::type(array1,
sourceComponent1);
vtkm::cont::ArrayHandle<ValueType1,Storage1> >::type(array1,
sourceComponent1);
}
template<typename ValueType1, typename Container1,
typename ValueType2, typename Container2>
template<typename ValueType1, typename Storage1,
typename ValueType2, typename Storage2>
VTKM_CONT_EXPORT
typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2> >::type
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2> >::type
make_ArrayHandleCompositeVector(
const vtkm::cont::ArrayHandle<ValueType1,Container1> &array1,
const vtkm::cont::ArrayHandle<ValueType1,Storage1> &array1,
int sourceComponent1,
const vtkm::cont::ArrayHandle<ValueType2,Container2> &array2,
const vtkm::cont::ArrayHandle<ValueType2,Storage2> &array2,
int sourceComponent2)
{
return typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2> >::type(array1,
sourceComponent1,
array2,
sourceComponent2);
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2> >::type(array1,
sourceComponent1,
array2,
sourceComponent2);
}
template<typename ValueType1, typename Container1,
typename ValueType2, typename Container2,
typename ValueType3, typename Container3>
template<typename ValueType1, typename Storage1,
typename ValueType2, typename Storage2,
typename ValueType3, typename Storage3>
VTKM_CONT_EXPORT
typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2>,
vtkm::cont::ArrayHandle<ValueType3,Container3> >::type
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2>,
vtkm::cont::ArrayHandle<ValueType3,Storage3> >::type
make_ArrayHandleCompositeVector(
const vtkm::cont::ArrayHandle<ValueType1,Container1> &array1,
const vtkm::cont::ArrayHandle<ValueType1,Storage1> &array1,
int sourceComponent1,
const vtkm::cont::ArrayHandle<ValueType2,Container2> &array2,
const vtkm::cont::ArrayHandle<ValueType2,Storage2> &array2,
int sourceComponent2,
const vtkm::cont::ArrayHandle<ValueType3,Container3> &array3,
const vtkm::cont::ArrayHandle<ValueType3,Storage3> &array3,
int sourceComponent3)
{
return typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2>,
vtkm::cont::ArrayHandle<ValueType3,Container3> >::type(array1,
sourceComponent1,
array2,
sourceComponent2,
array3,
sourceComponent3);
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2>,
vtkm::cont::ArrayHandle<ValueType3,Storage3> >::type(array1,
sourceComponent1,
array2,
sourceComponent2,
array3,
sourceComponent3);
}
template<typename ValueType1, typename Container1,
typename ValueType2, typename Container2,
typename ValueType3, typename Container3,
typename ValueType4, typename Container4>
template<typename ValueType1, typename Storage1,
typename ValueType2, typename Storage2,
typename ValueType3, typename Storage3,
typename ValueType4, typename Storage4>
VTKM_CONT_EXPORT
typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2>,
vtkm::cont::ArrayHandle<ValueType3,Container3>,
vtkm::cont::ArrayHandle<ValueType4,Container4> >::type
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2>,
vtkm::cont::ArrayHandle<ValueType3,Storage3>,
vtkm::cont::ArrayHandle<ValueType4,Storage4> >::type
make_ArrayHandleCompositeVector(
const vtkm::cont::ArrayHandle<ValueType1,Container1> &array1,
const vtkm::cont::ArrayHandle<ValueType1,Storage1> &array1,
int sourceComponent1,
const vtkm::cont::ArrayHandle<ValueType2,Container2> &array2,
const vtkm::cont::ArrayHandle<ValueType2,Storage2> &array2,
int sourceComponent2,
const vtkm::cont::ArrayHandle<ValueType3,Container3> &array3,
const vtkm::cont::ArrayHandle<ValueType3,Storage3> &array3,
int sourceComponent3,
const vtkm::cont::ArrayHandle<ValueType4,Container4> &array4,
const vtkm::cont::ArrayHandle<ValueType4,Storage4> &array4,
int sourceComponent4)
{
return typename ArrayHandleCompositeVectorType<
vtkm::cont::ArrayHandle<ValueType1,Container1>,
vtkm::cont::ArrayHandle<ValueType2,Container2>,
vtkm::cont::ArrayHandle<ValueType3,Container3>,
vtkm::cont::ArrayHandle<ValueType4,Container4> >::type(array1,
sourceComponent1,
array2,
sourceComponent2,
array3,
sourceComponent3,
array4,
sourceComponent4);
vtkm::cont::ArrayHandle<ValueType1,Storage1>,
vtkm::cont::ArrayHandle<ValueType2,Storage2>,
vtkm::cont::ArrayHandle<ValueType3,Storage3>,
vtkm::cont::ArrayHandle<ValueType4,Storage4> >::type(array1,
sourceComponent1,
array2,
sourceComponent2,
array3,
sourceComponent3,
array4,
sourceComponent4);
}
}

7
vtkm/cont/ArrayHandleCounting.h
View File

@ -20,8 +20,9 @@
#ifndef vtk_m_cont_ArrayHandleCounting_h
#define vtk_m_cont_ArrayHandleCounting_h
#include <vtkm/cont/ArrayContainerControlImplicit.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
namespace vtkm {
@ -92,11 +93,11 @@ private:
};
/// A convenience class that provides a typedef to the appropriate tag for
/// a counting array container.
/// a counting storage.
template<typename ConstantValueType>
struct ArrayHandleCountingTraits
{
typedef vtkm::cont::ArrayContainerControlTagImplicit<
typedef vtkm::cont::StorageTagImplicit<
vtkm::cont::internal::ArrayPortalCounting<ConstantValueType> > Tag;
};

6
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -22,8 +22,8 @@
#include <vtkm/Extent.h>
#include <vtkm/cont/ArrayContainerControlImplicit.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
@ -131,12 +131,12 @@ private:
class ArrayHandleUniformPointCoordinates
: public vtkm::cont::ArrayHandle<
vtkm::Vector3,
vtkm::cont::ArrayContainerControlTagImplicit<
vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> >
{
typedef vtkm::cont::ArrayHandle<
vtkm::Vector3,
vtkm::cont::ArrayContainerControlTagImplicit<
vtkm::cont::StorageTagImplicit<
internal::ArrayPortalUniformPointCoordinates> > Superclass;
public:

2
vtkm/cont/ArrayPortal.h
View File

@ -42,7 +42,7 @@ namespace cont {
/// An ArrayPortal differs from an ArrayHandle in that the ArrayPortal is a
/// much lighterweight object and that it does not manage things like
/// allocation and control/execution sharing. An ArrayPortal also differs from
/// an ArrayContainer in that it does not actually contain the data but rather
/// a Storage in that it does not actually contain the data but rather
/// points to it. In this way the ArrayPortal can be copied and passed and
/// still point to the same data.
///

8
vtkm/cont/CMakeLists.txt
View File

@ -21,16 +21,12 @@
include_directories(${Boost_INCLUDE_DIRS})
set(headers
ArrayContainerControl.h
ArrayContainerControlBasic.h
ArrayContainerControlImplicit.h
ArrayHandle.h
ArrayHandleCompositeVector.h
ArrayHandleCounting.h
ArrayHandleUniformPointCoordinates.h
ArrayPortal.h
Assert.h
ContainerListTag.h
DeviceAdapter.h
DeviceAdapterSerial.h
DynamicArrayHandle.h
@ -45,6 +41,10 @@ set(headers
PointCoordinatesArray.h
PointCoordinatesListTag.h
PointCoordinatesUniform.h
Storage.h
StorageBasic.h
StorageImplicit.h
StorageListTag.h
Timer.h
)

158
vtkm/cont/DynamicArrayHandle.h
View File

@ -23,8 +23,8 @@
#include <vtkm/TypeListTag.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ContainerListTag.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/StorageListTag.h>
#include <vtkm/cont/internal/DynamicTransform.h>
#include <vtkm/cont/internal/SimplePolymorphicContainer.h>
@ -38,10 +38,10 @@ namespace cont {
namespace internal {
/// Behaves like (and is interchangable with) a DynamicArrayHandle. The
/// difference is that the list of types and list of containers to try when
/// difference is that the list of types and list of storage to try when
/// calling CastAndCall is set to the class template arguments.
///
template<typename TypeList, typename ContainerList>
template<typename TypeList, typename StorageList>
class DynamicArrayHandleCast;
} // namespace internal
@ -57,15 +57,15 @@ class DynamicArrayHandleCast;
///
/// To interface between the runtime polymorphism and the templated algorithms
/// in VTK-m, \c DynamicArrayHandle contains a method named \c CastAndCall that
/// will determine the correct type from some known list of types and
/// containers. This mechanism is used internally by VTK-m's worklet invocation
/// will determine the correct type from some known list of types and storage
/// objects. This mechanism is used internally by VTK-m's worklet invocation
/// mechanism to determine the type when running algorithms.
///
/// By default, \c DynamicArrayHandle will assume that the value type in the
/// array matches one of the types specified by \c VTKM_DEFAULT_TYPE_LIST_TAG
/// and the container matches one of the tags specified by \c
/// VTKM_DEFAULT_CONTAINER_LIST_TAG. These lists can be changed by using the \c
/// ResetTypeList and \c ResetContainerList methods, respectively. It is
/// and the storage matches one of the tags specified by \c
/// VTKM_DEFAULT_STORAGE_LIST_TAG. These lists can be changed by using the \c
/// ResetTypeList and \c ResetStorageList methods, respectively. It is
/// worthwhile to match these lists closely to the possible types that might be
/// used. If a type is missing you will get a runtime error. If there are more
/// types than necessary, then the template mechanism will create a lot of
@ -79,39 +79,39 @@ public:
VTKM_CONT_EXPORT
DynamicArrayHandle() { }
template<typename Type, typename Container>
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
DynamicArrayHandle(const vtkm::cont::ArrayHandle<Type,Container> &array)
: ArrayContainer(new vtkm::cont::internal::SimplePolymorphicContainer<
vtkm::cont::ArrayHandle<Type,Container> >(array))
DynamicArrayHandle(const vtkm::cont::ArrayHandle<Type,Storage> &array)
: ArrayStorage(new vtkm::cont::internal::SimplePolymorphicContainer<
vtkm::cont::ArrayHandle<Type,Storage> >(array))
{ }
template<typename TypeList, typename ContainerList>
template<typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
DynamicArrayHandle(
const internal::DynamicArrayHandleCast<TypeList,ContainerList> &dynamicArray)
: ArrayContainer(dynamicArray.ArrayContainer) { }
const internal::DynamicArrayHandleCast<TypeList,StorageList> &dynamicArray)
: ArrayStorage(dynamicArray.ArrayStorage) { }
/// Returns true if this array is of the provided type and uses the provided
/// container.
/// storage.
///
template<typename Type, typename Container>
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
bool IsTypeAndContainer(Type = Type(), Container = Container()) const {
return (this->TryCastArrayContainer<Type,Container>() != NULL);
bool IsTypeAndStorage(Type = Type(), Storage = Storage()) const {
return (this->TryCastStorage<Type,Storage>() != NULL);
}
/// Returns this array cast to an ArrayHandle object of the given type and
/// container. Throws ErrorControlBadValue if the cast does not work. Use
/// IsTypeAndContainer to check if the cast can happen.
/// storage. Throws ErrorControlBadValue if the cast does not work. Use
/// IsTypeAndStorage to check if the cast can happen.
///
template<typename Type, typename Container>
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<Type, Container>
CastToArrayHandle(Type = Type(), Container = Container()) const {
vtkm::cont::ArrayHandle<Type, Storage>
CastToArrayHandle(Type = Type(), Storage = Storage()) const {
vtkm::cont::internal::SimplePolymorphicContainer<
vtkm::cont::ArrayHandle<Type,Container> > *container =
this->TryCastArrayContainer<Type,Container>();
vtkm::cont::ArrayHandle<Type,Storage> > *container =
this->TryCastStorage<Type,Storage>();
if (container == NULL)
{
throw vtkm::cont::ErrorControlBadValue("Bad cast of dynamic array.");
@ -128,104 +128,104 @@ public:
///
template<typename NewTypeList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<NewTypeList,VTKM_DEFAULT_CONTAINER_LIST_TAG>
internal::DynamicArrayHandleCast<NewTypeList,VTKM_DEFAULT_STORAGE_LIST_TAG>
ResetTypeList(NewTypeList = NewTypeList()) const {
return internal::DynamicArrayHandleCast<
NewTypeList,VTKM_DEFAULT_CONTAINER_LIST_TAG>(*this);
NewTypeList,VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
}
/// Changes the array containers to try casting to when resolving this
/// Changes the array storage types to try casting to when resolving this
/// dynamic array, which is specified with a list tag like those in
/// ContainerListTag.h. Since C++ does not allow you to actually change the
/// StorageListTag.h. Since C++ does not allow you to actually change the
/// template arguments, this method returns a new dynamic array object. This
/// method is particularly useful to narrow down (or expand) the types when
/// using an array of particular constraints.
///
template<typename NewContainerList>
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<VTKM_DEFAULT_TYPE_LIST_TAG,NewContainerList>
ResetContainerList(NewContainerList = NewContainerList()) const {
internal::DynamicArrayHandleCast<VTKM_DEFAULT_TYPE_LIST_TAG,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
return internal::DynamicArrayHandleCast<
VTKM_DEFAULT_TYPE_LIST_TAG,NewContainerList>(*this);
VTKM_DEFAULT_TYPE_LIST_TAG,NewStorageList>(*this);
}
/// Attempts to cast the held array to a specific value type and container,
/// then call the given functor with the cast array. The types and containers
/// Attempts to cast the held array to a specific value type and storage,
/// then call the given functor with the cast array. The types and storage
/// tried in the cast are those in the lists defined by
/// VTKM_DEFAULT_TYPE_LIST_TAG and VTKM_DEFAULT_CONTAINER_LIST_TAG,
/// VTKM_DEFAULT_TYPE_LIST_TAG and VTK_DEFAULT_STORAGE_LIST_TAG,
/// respectively, unless they have been changed with a previous call to
/// ResetTypeList or ResetContainerList.
/// ResetTypeList or ResetStorageList.
///
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(
f, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_CONTAINER_LIST_TAG());
f, VTKM_DEFAULT_TYPE_LIST_TAG(), VTKM_DEFAULT_STORAGE_LIST_TAG());
}
/// A version of CastAndCall that tries specified lists of types and
/// containers.
/// storage types.
///
template<typename Functor, typename TypeList, typename ContainerList>
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, ContainerList) const;
void CastAndCall(const Functor &f, TypeList, StorageList) const;
private:
boost::shared_ptr<vtkm::cont::internal::SimplePolymorphicContainerBase>
ArrayContainer;
ArrayStorage;
template<typename Type, typename Container>
template<typename Type, typename Storage>
VTKM_CONT_EXPORT
vtkm::cont::internal::SimplePolymorphicContainer<
vtkm::cont::ArrayHandle<Type,Container> > *
TryCastArrayContainer() const {
vtkm::cont::ArrayHandle<Type,Storage> > *
TryCastStorage() const {
return
dynamic_cast<
vtkm::cont::internal::SimplePolymorphicContainer<
vtkm::cont::ArrayHandle<Type,Container> > *>(
this->ArrayContainer.get());
vtkm::cont::ArrayHandle<Type,Storage> > *>(
this->ArrayStorage.get());
}
};
namespace detail {
template<typename Functor, typename Type>
struct DynamicArrayHandleTryContainer {
struct DynamicArrayHandleTryStorage {
const DynamicArrayHandle Array;
const Functor &Function;
bool FoundCast;
VTKM_CONT_EXPORT
DynamicArrayHandleTryContainer(const DynamicArrayHandle &array,
DynamicArrayHandleTryStorage(const DynamicArrayHandle &array,
const Functor &f)
: Array(array), Function(f), FoundCast(false) { }
template<typename Container>
template<typename Storage>
VTKM_CONT_EXPORT
typename boost::enable_if<
typename vtkm::cont::internal::IsValidArrayHandle<Type,Container>::type
typename vtkm::cont::internal::IsValidArrayHandle<Type,Storage>::type
>::type
operator()(Container) {
operator()(Storage) {
if (!this->FoundCast &&
this->Array.IsTypeAndContainer(Type(), Container()))
this->Array.IsTypeAndStorage(Type(), Storage()))
{
this->Function(this->Array.CastToArrayHandle(Type(), Container()));
this->Function(this->Array.CastToArrayHandle(Type(), Storage()));
this->FoundCast = true;
}
}
template<typename Container>
template<typename Storage>
VTKM_CONT_EXPORT
typename boost::disable_if<
typename vtkm::cont::internal::IsValidArrayHandle<Type,Container>::type
typename vtkm::cont::internal::IsValidArrayHandle<Type,Storage>::type
>::type
operator()(Container) {
operator()(Storage) {
// This type of array handle cannot exist, so do nothing.
}
};
template<typename Functor, typename ContainerList>
template<typename Functor, typename StorageList>
struct DynamicArrayHandleTryType {
const DynamicArrayHandle Array;
const Functor &Function;
@ -239,11 +239,11 @@ struct DynamicArrayHandleTryType {
VTKM_CONT_EXPORT
void operator()(Type) {
if (this->FoundCast) { return; }
typedef DynamicArrayHandleTryContainer<Functor, Type> TryContainerType;
TryContainerType tryContainer =
TryContainerType(this->Array, this->Function);
vtkm::ListForEach(tryContainer, ContainerList());
if (tryContainer.FoundCast)
typedef DynamicArrayHandleTryStorage<Functor, Type> TryStorageType;
TryStorageType tryStorage =
TryStorageType(this->Array, this->Function);
vtkm::ListForEach(tryStorage, StorageList());
if (tryStorage.FoundCast)
{
this->FoundCast = true;
}
@ -252,13 +252,13 @@ struct DynamicArrayHandleTryType {
} // namespace detail
template<typename Functor, typename TypeList, typename ContainerList>
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void DynamicArrayHandle::CastAndCall(const Functor &f,
TypeList,
ContainerList) const
StorageList) const
{
typedef detail::DynamicArrayHandleTryType<Functor, ContainerList> TryTypeType;
typedef detail::DynamicArrayHandleTryType<Functor, StorageList> TryTypeType;
TryTypeType tryType = TryTypeType(*this, f);
vtkm::ListForEach(tryType, TypeList());
if (!tryType.FoundCast)
@ -270,7 +270,7 @@ void DynamicArrayHandle::CastAndCall(const Functor &f,
namespace internal {
template<typename TypeList, typename ContainerList>
template<typename TypeList, typename StorageList>
class DynamicArrayHandleCast : public vtkm::cont::DynamicArrayHandle
{
public:
@ -281,31 +281,31 @@ public:
DynamicArrayHandleCast(const vtkm::cont::DynamicArrayHandle &array)
: DynamicArrayHandle(array) { }
template<typename SrcTypeList, typename SrcContainerList>
template<typename SrcTypeList, typename SrcStorageList>
VTKM_CONT_EXPORT
DynamicArrayHandleCast(
const DynamicArrayHandleCast<SrcTypeList,SrcContainerList> &array)
const DynamicArrayHandleCast<SrcTypeList,SrcStorageList> &array)
: DynamicArrayHandle(array) { }
template<typename NewTypeList>
VTKM_CONT_EXPORT
DynamicArrayHandleCast<NewTypeList,ContainerList>
DynamicArrayHandleCast<NewTypeList,StorageList>
ResetTypeList(NewTypeList = NewTypeList()) const {
return DynamicArrayHandleCast<NewTypeList,ContainerList>(*this);
return DynamicArrayHandleCast<NewTypeList,StorageList>(*this);
}
template<typename NewContainerList>
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicArrayHandleCast<TypeList,NewContainerList>
ResetContainerList(NewContainerList = NewContainerList()) const {
return internal::DynamicArrayHandleCast<TypeList,NewContainerList>(*this);
internal::DynamicArrayHandleCast<TypeList,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
return internal::DynamicArrayHandleCast<TypeList,NewStorageList>(*this);
}
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(f, TypeList(), ContainerList());
this->CastAndCall(f, TypeList(), StorageList());
}
template<typename Functor, typename TL, typename CL>
@ -321,9 +321,9 @@ struct DynamicTransformTraits<vtkm::cont::DynamicArrayHandle> {
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
template<typename TypeList, typename ContainerList>
template<typename TypeList, typename StorageList>
struct DynamicTransformTraits<
vtkm::cont::internal::DynamicArrayHandleCast<TypeList,ContainerList> >
vtkm::cont::internal::DynamicArrayHandleCast<TypeList,StorageList> >
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};

88
vtkm/cont/DynamicPointCoordinates.h
View File

@ -36,12 +36,12 @@ namespace internal {
/// Behaves like (and is interchangable with) a \c DynamicPointCoordinates. The
/// difference is that the lists of point coordinates, base types, and
/// containers to try when calling \c CastAndCall is set to the class template
/// storage to try when calling \c CastAndCall is set to the class template
/// arguments.
///
template<typename PointCoordinatesList,
typename TypeList,
typename ContainerList>
typename StorageList>
class DynamicPointCoordinatesCast;
} // namespace internal
@ -67,9 +67,9 @@ class DynamicPointCoordinatesCast;
///
/// Internally, some \c PointCoordinates objects will reference dynamic arrays.
/// Thus, \c DynamicPointCoordinates also maintains lists of types and
/// containers that these subarrays might use. These default to \c
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_CONTAINER_LIST_TAG and can
/// be changed with the \c ResetTypeList and \c ResetContainerList methods.
/// storage that these subarrays might use. These default to \c
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_STORAGE_LIST_TAG and can
/// be changed with the \c ResetTypeList and \c ResetStorageList methods.
///
class DynamicPointCoordinates
{
@ -88,10 +88,10 @@ public:
/// Special constructor for the common case of using a basic array to store
/// point coordinates.
///
template<typename Container>
template<typename Storage>
VTKM_CONT_EXPORT
DynamicPointCoordinates(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Container> &array)
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array)
: PointCoordinatesContainer(new vtkm::cont::PointCoordinatesArray(array))
{ }
@ -152,13 +152,13 @@ public:
internal::DynamicPointCoordinatesCast<
NewPointCoordinatesList,
VTKM_DEFAULT_TYPE_LIST_TAG,
VTKM_DEFAULT_CONTAINER_LIST_TAG>
VTKM_DEFAULT_STORAGE_LIST_TAG>
ResetPointCoordinatesList(
NewPointCoordinatesList = NewPointCoordinatesList()) const {
return internal::DynamicPointCoordinatesCast<
NewPointCoordinatesList,
VTKM_DEFAULT_TYPE_LIST_TAG,
VTKM_DEFAULT_CONTAINER_LIST_TAG>(*this);
VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
}
/// Changes the types to try casting to when resolving dynamic arrays within
@ -173,32 +173,32 @@ public:
internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
NewTypeList,
VTKM_DEFAULT_CONTAINER_LIST_TAG>
VTKM_DEFAULT_STORAGE_LIST_TAG>
ResetTypeList(NewTypeList = NewTypeList()) const {
return internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
NewTypeList,
VTKM_DEFAULT_CONTAINER_LIST_TAG>(*this);
VTKM_DEFAULT_STORAGE_LIST_TAG>(*this);
}
/// Changes the array containers to try casting to when resolving dynamic
/// Changes the array storage to try casting to when resolving dynamic
/// arrays within the point coordinates container, which is specified with a
/// list tag like those in ContainerListTag.h. Since C++ does not allow you
/// list tag like those in StorageListTag.h. Since C++ does not allow you
/// to actually change the template arguments, this method returns a new
/// dynamic array object. This method is particularly useful to narrow down
/// (or expand) the types when using an array of particular constraints.
///
template<typename NewContainerList>
template<typename NewStorageList>
VTKM_CONT_EXPORT
internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
VTKM_DEFAULT_TYPE_LIST_TAG,
NewContainerList>
ResetContainerList(NewContainerList = NewContainerList()) const {
NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
return internal::DynamicPointCoordinatesCast<
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG,
VTKM_DEFAULT_TYPE_LIST_TAG,
NewContainerList>(*this);
NewStorageList>(*this);
}
/// Attempts to cast the held point coordinates to a specific array
@ -209,7 +209,7 @@ public:
///
/// The second part then asks the concrete \c PointCoordinates object to cast
/// and call to a concrete array. This second cast might rely on \c
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_CONTAINER_LIST_TAG.
/// VTKM_DEFAULT_TYPE_LIST_TAG and \c VTKM_DEFAULT_STORAGE_LIST_TAG.
///
template<typename Functor>
VTKM_CONT_EXPORT
@ -218,21 +218,21 @@ public:
this->CastAndCall(f,
VTKM_DEFAULT_POINT_COORDINATES_LIST_TAG(),
VTKM_DEFAULT_TYPE_LIST_TAG(),
VTKM_DEFAULT_CONTAINER_LIST_TAG());
VTKM_DEFAULT_STORAGE_LIST_TAG());
}
/// A version of \c CastAndCall that tries specified lists of point
/// coordinates, types, and containers.
/// coordinates, types, and storage.
///
template<typename Functor,
typename PointCoordinatesList,
typename TypeList,
typename ContainerList>
typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f,
PointCoordinatesList,
TypeList,
ContainerList) const;
StorageList) const;
private:
boost::shared_ptr<vtkm::cont::internal::PointCoordinatesBase>
@ -250,15 +250,15 @@ private:
namespace detail {
template<typename Functor, typename TypeList, typename ContainerList>
struct DynamicPointCoordinatesTryContainer
template<typename Functor, typename TypeList, typename StorageList>
struct DynamicPointCoordinatesTryStorage
{
const DynamicPointCoordinates PointCoordinates;
const Functor &Function;
bool FoundCast;
VTKM_CONT_EXPORT
DynamicPointCoordinatesTryContainer(
DynamicPointCoordinatesTryStorage(
const DynamicPointCoordinates &pointCoordinates,
const Functor &f)
: PointCoordinates(pointCoordinates), Function(f), FoundCast(false)
@ -272,7 +272,7 @@ struct DynamicPointCoordinatesTryContainer
{
PointCoordinatesType pointCoordinates =
this->PointCoordinates.CastToPointCoordinates(PointCoordinatesType());
pointCoordinates.CastAndCall(this->Function, TypeList(), ContainerList());
pointCoordinates.CastAndCall(this->Function, TypeList(), StorageList());
this->FoundCast = true;
}
}
@ -283,15 +283,15 @@ struct DynamicPointCoordinatesTryContainer
template<typename Functor,
typename PointCoordinatesList,
typename TypeList,
typename ContainerList>
typename StorageList>
VTKM_CONT_EXPORT
void DynamicPointCoordinates::CastAndCall(const Functor &f,
PointCoordinatesList,
TypeList,
ContainerList) const
StorageList) const
{
typedef detail::DynamicPointCoordinatesTryContainer<
Functor, TypeList, ContainerList> TryTypeType;
typedef detail::DynamicPointCoordinatesTryStorage<
Functor, TypeList, StorageList> TryTypeType;
TryTypeType tryType = TryTypeType(*this, f);
vtkm::ListForEach(tryType, PointCoordinatesList());
if (!tryType.FoundCast)
@ -305,7 +305,7 @@ namespace internal {
template<typename PointCoordinatesList,
typename TypeList,
typename ContainerList>
typename StorageList>
class DynamicPointCoordinatesCast : public vtkm::cont::DynamicPointCoordinates
{
public:
@ -318,43 +318,43 @@ public:
template<typename SrcPointCoordinatesList,
typename SrcTypeList,
typename SrcContainerList>
typename SrcStorageList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast(
const DynamicPointCoordinatesCast<SrcPointCoordinatesList,SrcTypeList,SrcContainerList> &coords)
const DynamicPointCoordinatesCast<SrcPointCoordinatesList,SrcTypeList,SrcStorageList> &coords)
: DynamicPointCoordinates(coords)
{ }
template<typename NewPointCoordinatesList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<NewPointCoordinatesList,TypeList,ContainerList>
DynamicPointCoordinatesCast<NewPointCoordinatesList,TypeList,StorageList>
ResetPointCoordinatesList(
NewPointCoordinatesList = NewPointCoordinatesList()) const {
return DynamicPointCoordinatesCast<
NewPointCoordinatesList,TypeList,ContainerList>(*this);
NewPointCoordinatesList,TypeList,StorageList>(*this);
}
template<typename NewTypeList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<PointCoordinatesList,NewTypeList,ContainerList>
DynamicPointCoordinatesCast<PointCoordinatesList,NewTypeList,StorageList>
ResetTypeList(NewTypeList = NewTypeList()) const {
return DynamicPointCoordinatesCast<
PointCoordinatesList,NewTypeList,ContainerList>(*this);
PointCoordinatesList,NewTypeList,StorageList>(*this);
}
template<typename NewContainerList>
template<typename NewStorageList>
VTKM_CONT_EXPORT
DynamicPointCoordinatesCast<PointCoordinatesList,TypeList,NewContainerList>
ResetContainerList(NewContainerList = NewContainerList()) const {
DynamicPointCoordinatesCast<PointCoordinatesList,TypeList,NewStorageList>
ResetStorageList(NewStorageList = NewStorageList()) const {
return DynamicPointCoordinatesCast<
PointCoordinatesList,TypeList,NewContainerList>(*this);
PointCoordinatesList,TypeList,NewStorageList>(*this);
}
template<typename Functor>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f) const
{
this->CastAndCall(f, PointCoordinatesList(), TypeList(), ContainerList());
this->CastAndCall(f, PointCoordinatesList(), TypeList(), StorageList());
}
template<typename Functor, typename PCL, typename TL, typename CL>
@ -372,10 +372,10 @@ struct DynamicTransformTraits<vtkm::cont::DynamicPointCoordinates> {
template<typename PointCoordinatesList,
typename TypeList,
typename ContainerList>
typename StorageList>
struct DynamicTransformTraits<
vtkm::cont::internal::DynamicPointCoordinatesCast<
PointCoordinatesList,TypeList,ContainerList> >
PointCoordinatesList,TypeList,StorageList> >
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};

10
vtkm/cont/PointCoordinatesArray.h
View File

@ -49,20 +49,20 @@ public:
PointCoordinatesArray(const vtkm::cont::DynamicArrayHandle &array)
: Array(array) { }
template<typename Container>
template<typename Storage>
VTKM_CONT_EXPORT
PointCoordinatesArray(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Container> &array)
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array)
: Array(array) { }
/// In this \c CastAndCall, \c TypeList is ignored. All point coordinates are
/// expressed as Vector3, so that must be how the array is represented.
///
template<typename Functor, typename TypeList, typename ContainerList>
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, ContainerList) const
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
this->Array.CastAndCall(f, vtkm::TypeListTagVector3(), ContainerList());
this->Array.CastAndCall(f, vtkm::TypeListTagVector3(), StorageList());
}
private:

6
vtkm/cont/PointCoordinatesUniform.h
View File

@ -49,13 +49,13 @@ public:
: Array(extent, origin, spacing)
{ }
/// In this \c CastAndCall, both \c TypeList and \c ContainerList are
/// In this \c CastAndCall, both \c TypeList and \c StorageList are
/// ignored. All point coordinates are expressed as Vector3, so that must be
/// how the array is represented.
///
template<typename Functor, typename TypeList, typename ContainerList>
template<typename Functor, typename TypeList, typename StorageList>
VTKM_CONT_EXPORT
void CastAndCall(const Functor &f, TypeList, ContainerList) const
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
f(this->Array);
}

101
vtkm/cont/ArrayContainerControl.h → vtkm/cont/Storage.h
View File

@ -17,15 +17,15 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont__ArrayContainerControl_h
#define vtk_m_cont__ArrayContainerControl_h
#ifndef vtk_m_cont_Storage_h
#define vtk_m_cont_Storage_h
#define VTKM_ARRAY_CONTAINER_CONTROL_ERROR -2
#define VTKM_ARRAY_CONTAINER_CONTROL_UNDEFINED -1
#define VTKM_ARRAY_CONTAINER_CONTROL_BASIC 1
#define VTKM_STORAGE_ERROR -2
#define VTKM_STORAGE_UNDEFINED -1
#define VTKM_STORAGE_BASIC 1
#ifndef VTKM_ARRAY_CONTAINER_CONTROL
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_BASIC
#ifndef VTKM_STORAGE
#define VTKM_STORAGE VTKM_STORAGE_BASIC
#endif
#include <boost/static_assert.hpp>
@ -36,42 +36,40 @@ namespace cont {
#ifdef VTKM_DOXYGEN_ONLY
/// \brief A tag specifying client memory allocation.
///
/// An ArrayContainerControl tag specifies how an ArrayHandle allocates and
/// frees memory. The tag ArrayContainerControlTag___ does not actually exist.
/// Rather, this documentation is provided to describe how array containers are
/// specified. Loading the vtkm/cont/ArrayContainerControl.h header will set a
/// default array container. You can specify the default array container by
/// first setting the VTKM_ARRAY_CONTAINER_CONTROL macro. Currently it can only
/// be set to VTKM_ARRAY_CONTAINER_CONTROL_BASIC.
/// A Storage tag specifies how an ArrayHandle allocates and frees memory. The
/// tag StorageTag___ does not actually exist. Rather, this documentation is
/// provided to describe how array storage objects are specified. Loading the
/// vtkm/cont/Storage.h header will set a default array storage. You can
/// specify the default storage by first setting the VTKM_STORAGE macro.
/// Currently it can only be set to VTKM_STORAGE_BASIC.
///
/// User code external to VTKm is free to make its own ArrayContainerControlTag.
/// This is a good way to get VTKm to read data directly in and out of arrays
/// from other libraries. However, care should be taken when creating an
/// ArrayContainerControl. One particular problem that is likely is a container
/// that "constructs" all the items in the array. If done incorrectly, then
/// memory of the array can be incorrectly bound to the wrong process. If you
/// do provide your own ArrayContainerControlTag, please be diligent in
/// comparing its performance to the ArrayContainerControlTagBasic.
/// User code external to VTK-m is free to make its own StorageTag. This is a
/// good way to get VTK-m to read data directly in and out of arrays from other
/// libraries. However, care should be taken when creating a Storage. One
/// particular problem that is likely is a storage that "constructs" all the
/// items in the array. If done incorrectly, then memory of the array can be
/// incorrectly bound to the wrong processor. If you do provide your own
/// StorageTag, please be diligent in comparing its performance to the
/// StorageTagBasic.
///
/// To implement your own ArrayContainerControlTag, you first must create a tag
/// class (an empty struct) defining your tag (i.e. struct
/// ArrayContainerControlTagMyAlloc { };). Then provide a partial template
/// specialization of vtkm::cont::internal::ArrayContainerControl for your new
/// tag.
/// To implement your own StorageTag, you first must create a tag class (an
/// empty struct) defining your tag (i.e. struct StorageTagMyAlloc { };). Then
/// provide a partial template specialization of vtkm::cont::internal::Storage
/// for your new tag.
///
struct ArrayContainerControlTag___ { };
struct StorageTag___ { };
#endif // VTKM_DOXYGEN_ONLY
namespace internal {
struct UndefinedArrayContainerControl { };
struct UndefinedStorage { };
namespace detail {
// This class should never be used. It is used as a placeholder for undefined
// ArrayContainerControl objects. If you get a compiler error involving this
// object, then it probably comes from trying to use an ArrayHandle with bad
// template arguments.
// Storage objects. If you get a compiler error involving this object, then it
// probably comes from trying to use an ArrayHandle with bad template
// arguments.
template<typename T>
struct UndefinedArrayPortal {
BOOST_STATIC_ASSERT(sizeof(T) == -1);
@ -79,14 +77,13 @@ struct UndefinedArrayPortal {
} // namespace detail
/// This templated class must be partially specialized for each
/// ArrayContainerControlTag created, which will define the implementation for
/// that tag.
/// This templated class must be partially specialized for each StorageTag
/// created, which will define the implementation for that tag.
///
template<typename T, class ArrayContainerControlTag>
class ArrayContainerControl
template<typename T, class StorageTag>
class Storage
#ifndef VTKM_DOXYGEN_ONLY
: public vtkm::cont::internal::UndefinedArrayContainerControl
: public vtkm::cont::internal::UndefinedStorage
{
public:
typedef vtkm::cont::internal::detail::UndefinedArrayPortal<T> PortalType;
@ -152,7 +149,7 @@ public:
///
/// After calling this method GetNumberOfValues will return 0 and
/// GetIteratorBegin and GetIteratorEnd will return the same iterator. The
/// resources should also be released when the ArrayContainerControl class is
/// resources should also be released when the Storage class is
/// destroyed.
VTKM_CONT_EXPORT
void ReleaseResources();
@ -164,27 +161,25 @@ public:
}
} // namespace vtkm::cont
// This is put at the bottom of the header so that the ArrayContainerControl
// template is declared before any implementations are called.
// This is put at the bottom of the header so that the Storage template is
// declared before any implementations are called.
#if VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_BASIC
#if VTKM_STORAGE == VTKM_STORAGE_BASIC
#include <vtkm/cont/ArrayContainerControlBasic.h>
#define VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG \
::vtkm::cont::ArrayContainerControlTagBasic
#include <vtkm/cont/StorageBasic.h>
#define VTKM_DEFAULT_STORAGE_TAG ::vtkm::cont::StorageTagBasic
#elif VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_ERROR
#elif VTKM_STORAGE == VTKM_STORAGE_ERROR
#include <vtkm/cont/internal/ArrayContainerControlError.h>
#define VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG \
::vtkm::cont::internal::ArrayContainerControlTagError
#include <vtkm/cont/internal/StorageError.h>
#define VTKM_DEFAULT_STORAGE_TAG ::vtkm::cont::internal::StorageTagError
#elif (VTKM_ARRAY_CONTAINER_CONTROL == VTKM_ARRAY_CONTAINER_CONTROL_UNDEFINED) || !defined(VTKM_ARRAY_CONTAINER_CONTROL)
#elif (VTKM_STORAGE == VTKM_STORAGE_UNDEFINED) || !defined(VTKM_STORAGE)
#ifndef VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG
#warning If array container for control is undefined, VTKM_DEFAULT_ARRAY_CONTAINER_CONTROL_TAG must be defined.
#ifndef VTKM_DEFAULT_STORAGE_TAG
#warning If array storage is undefined, VTKM_DEFAULT_STORAGE_TAG must be defined.
#endif
#endif
#endif //vtk_m_cont__ArrayContainerControl_h
#endif //vtk_m_cont_Storage_h

43
vtkm/cont/ArrayContainerControlBasic.h → vtkm/cont/StorageBasic.h
View File

@ -17,34 +17,35 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont__ArrayContainerControlBasic_h
#define vtk_m_cont__ArrayContainerControlBasic_h
#ifndef vtk_m_cont_StorageBasic_h
#define vtk_m_cont_StorageBasic_h
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/Assert.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/ErrorControlOutOfMemory.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayPortalFromIterators.h>
namespace vtkm {
namespace cont {
/// A tag for the basic implementation of an ArrayContainerControl object.
struct ArrayContainerControlTagBasic { };
/// A tag for the basic implementation of a Storage object.
struct StorageTagBasic { };
namespace internal {
/// A basic implementation of an ArrayContainerControl object.
/// A basic implementation of an Storage object.
///
/// \todo This container does \em not construct the values within the array.
/// \todo This storage does \em not construct the values within the array.
/// Thus, it is important to not use this class with any type that will fail if
/// not constructed. These are things like basic types (int, float, etc.) and
/// the VTKm Tuple classes. In the future it would be nice to have a compile
/// time check to enforce this.
///
template <typename ValueT>
class ArrayContainerControl<ValueT, vtkm::cont::ArrayContainerControlTagBasic>
class Storage<ValueT, vtkm::cont::StorageTagBasic>
{
public:
typedef ValueT ValueType;
@ -54,18 +55,18 @@ public:
private:
/// The original design of this class provided an allocator as a template
/// parameters. That messed things up, though, because other templated
/// classes assume that the \c ArrayContainerControl has one template
/// parameter. There are other ways to allow you to specify the allocator,
/// but it is uncertain whether that would ever be useful. So, instead of
/// jumping through hoops implementing them, just fix the allocator for now.
/// classes assume that the \c Storage has one template parameter. There are
/// other ways to allow you to specify the allocator, but it is uncertain
/// whether that would ever be useful. So, instead of jumping through hoops
/// implementing them, just fix the allocator for now.
///
typedef std::allocator<ValueType> AllocatorType;
public:
ArrayContainerControl() : Array(NULL), NumberOfValues(0), AllocatedSize(0) { }
Storage() : Array(NULL), NumberOfValues(0), AllocatedSize(0) { }
~ArrayContainerControl()
~Storage()
{
this->ReleaseResources();
}
@ -152,10 +153,10 @@ public:
///
/// This method returns the pointer to the array held by this array. It then
/// clears the internal array pointer to NULL, thereby ensuring that the
/// ArrayContainerControl will never deallocate the array. This is
/// helpful for taking a reference for an array created internally by VTKm and
/// not having to keep a VTKm object around. Obviously the caller becomes
/// responsible for destroying the memory.
/// Storage will never deallocate the array. This is helpful for taking a
/// reference for an array created internally by VTK-m and not having to keep
/// a VTK-m object around. Obviously the caller becomes responsible for
/// destroying the memory.
///
ValueType *StealArray()
{
@ -168,8 +169,8 @@ public:
private:
// Not implemented.
ArrayContainerControl(const ArrayContainerControl<ValueType, ArrayContainerControlTagBasic> &src);
void operator=(const ArrayContainerControl<ValueType, ArrayContainerControlTagBasic> &src);
Storage(const Storage<ValueType, StorageTagBasic> &src);
void operator=(const Storage<ValueType, StorageTagBasic> &src);
ValueType *Array;
vtkm::Id NumberOfValues;
@ -181,4 +182,4 @@ private:
}
} // namespace vtkm::cont
#endif //vtk_m_cont__ArrayContainerControlBasic_h
#endif //vtk_m_cont_StorageBasic_h

81
vtkm/cont/ArrayContainerControlImplicit.h → vtkm/cont/StorageImplicit.h
View File

@ -17,14 +17,15 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ArrayContainerControlImplicit
#define vtk_m_cont_ArrayContainerControlImplicit
#ifndef vtk_m_cont_StorageImplicit
#define vtk_m_cont_StorageImplicit
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/Assert.h>
#include <vtkm/cont/ErrorControlBadValue.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
namespace vtkm {
@ -32,19 +33,16 @@ namespace cont {
/// \brief An implementation for read-only implicit arrays.
///
/// It is sometimes the case that you want VTKm to operate on an array of
/// It is sometimes the case that you want VTK-m to operate on an array of
/// implicit values. That is, rather than store the data in an actual array, it
/// is gerenated on the fly by a function. This is handled in VTKm by creating
/// an ArrayHandle in VTKm with an ArrayContainerControlTagImplicit type of
/// ArrayContainerControl. This tag itself is templated to specify an
/// ArrayPortal that generates the desired values. An ArrayHandle created with
/// this tag will raise an error on any operation that tries to modify it.
///
/// \todo The ArrayHandle currently copies the array in cases where the control
/// and environment do not share memory. This is wasteful and should be fixed.
/// is gerenated on the fly by a function. This is handled in VTK-m by creating
/// an ArrayHandle in VTK-m with a StorageTagImplicit type of \c Storage. This
/// tag itself is templated to specify an ArrayPortal that generates the
/// desired values. An ArrayHandle created with this tag will raise an error on
/// any operation that tries to modify it.
///
template<class ArrayPortalType>
struct ArrayContainerControlTagImplicit
struct StorageTagImplicit
{
typedef ArrayPortalType PortalType;
};
@ -52,9 +50,9 @@ struct ArrayContainerControlTagImplicit
namespace internal {
template<class ArrayPortalType>
class ArrayContainerControl<
class Storage<
typename ArrayPortalType::ValueType,
ArrayContainerControlTagImplicit<ArrayPortalType> >
StorageTagImplicit<ArrayPortalType> >
{
public:
typedef typename ArrayPortalType::ValueType ValueType;
@ -76,18 +74,18 @@ public:
PortalConstType GetPortalConst() const
{
// This does not work because the ArrayHandle holds the constant
// ArrayPortal, not the container.
// ArrayPortal, not the storage.
throw vtkm::cont::ErrorControlBadValue(
"Implicit container does not store array portal. "
"Implicit storage does not store array portal. "
"Perhaps you did not set the ArrayPortal when "
"constructing the ArrayHandle.");
}
vtkm::Id GetNumberOfValues() const
{
// This does not work because the ArrayHandle holds the constant
// ArrayPortal, not the container.
// ArrayPortal, not the Storage.
throw vtkm::cont::ErrorControlBadValue(
"Implicit container does not store array portal. "
"Implicit storage does not store array portal. "
"Perhaps you did not set the ArrayPortal when "
"constructing the ArrayHandle.");
}
@ -105,43 +103,18 @@ public:
}
};
//// If you are using this specalization of ArrayContainerControl, it means the
//// type of an ArrayHandle does not match the type of the array portal for the
//// array portal in an implicit array. Currently this use is invalid, but there
//// could be a case for implementing casting where appropriate.
//template<typename T, typename ArrayPortalType>
//class ArrayContainerControl<T, ArrayContainerControlTagImplicit<ArrayPortalType> >
//{
//public:
// // This is meant to be invalid because this class should not actually be used.
// struct PortalType
// {
// typedef void *ValueType;
// typedef void *IteratorType;
// };
// // This is meant to be invalid because this class should not actually be used.
// struct PortalConstType
// {
// typedef void *ValueType;
// typedef void *IteratorType;
// };
//};
template<typename T, class ArrayPortalType, class DeviceAdapterTag>
class ArrayTransfer<
T, ArrayContainerControlTagImplicit<ArrayPortalType>, DeviceAdapterTag>
class ArrayTransfer<T, StorageTagImplicit<ArrayPortalType>, DeviceAdapterTag>
{
private:
typedef ArrayContainerControlTagImplicit<ArrayPortalType>
ArrayContainerControlTag;
typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
ContainerType;
typedef StorageTagImplicit<ArrayPortalType> StorageTag;
typedef vtkm::cont::internal::Storage<T,StorageTag> StorageType;
public:
typedef T ValueType;
typedef typename ContainerType::PortalType PortalControl;
typedef typename ContainerType::PortalConstType PortalConstControl;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef PortalControl PortalExecution;
typedef PortalConstControl PortalConstExecution;
@ -159,27 +132,27 @@ public:
this->PortalValid = true;
}
VTKM_CONT_EXPORT void LoadDataForInput(const ContainerType &controlArray)
VTKM_CONT_EXPORT void LoadDataForInput(const StorageType &controlArray)
{
this->LoadDataForInput(controlArray.GetPortalConst());
}
VTKM_CONT_EXPORT
void LoadDataForInPlace(ContainerType &vtkmNotUsed(controlArray))
void LoadDataForInPlace(StorageType &vtkmNotUsed(controlArray))
{
throw vtkm::cont::ErrorControlBadValue(
"Implicit arrays cannot be used for output or in place.");
}
VTKM_CONT_EXPORT void AllocateArrayForOutput(
ContainerType &vtkmNotUsed(controlArray),
StorageType &vtkmNotUsed(controlArray),
vtkm::Id vtkmNotUsed(numberOfValues))
{
throw vtkm::cont::ErrorControlBadValue(
"Implicit arrays cannot be used for output.");
}
VTKM_CONT_EXPORT void RetrieveOutputData(
ContainerType &vtkmNotUsed(controlArray)) const
StorageType &vtkmNotUsed(controlArray)) const
{
throw vtkm::cont::ErrorControlBadValue(
"Implicit arrays cannot be used for output.");
@ -213,4 +186,4 @@ private:
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ArrayContainerControlImplicit
#endif //vtk_m_cont_StorageImplicit

18
vtkm/cont/ContainerListTag.h → vtkm/cont/StorageListTag.h
View File

@ -17,25 +17,25 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_ContainerListTag_h
#define vtk_m_ContainerListTag_h
#ifndef vtk_m_StorageListTag_h
#define vtk_m_StorageListTag_h
#ifndef VTKM_DEFAULT_CONTAINER_LIST_TAG
#define VTKM_DEFAULT_CONTAINER_LIST_TAG ::vtkm::cont::ContainerListTagBasic
#ifndef VTKM_DEFAULT_STORAGE_LIST_TAG
#define VTKM_DEFAULT_STORAGE_LIST_TAG ::vtkm::cont::StorageListTagBasic
#endif
#include <vtkm/ListTag.h>
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/StorageBasic.h>
namespace vtkm {
namespace cont {
struct ContainerListTagBasic
: vtkm::ListTagBase<vtkm::cont::ArrayContainerControlTagBasic> { };
struct StorageListTagBasic
: vtkm::ListTagBase<vtkm::cont::StorageTagBasic> { };
}
} // namespace vtkm::cont
#endif //vtk_m_ContainerListTag_h
#endif //vtk_m_StorageListTag_h

52
vtkm/cont/internal/ArrayHandleExecutionManager.h
View File

@ -20,8 +20,9 @@
#ifndef vtk_m_cont_exec_ArrayHandleExecutionManager_h
#define vtk_m_cont_exec_ArrayHandleExecutionManager_h
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/ErrorControlInternal.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
namespace vtkm {
@ -31,19 +32,18 @@ namespace internal {
/// The common base for ArrayHandleExecutionManager. This is the interface
/// used when the type of the device is not known at run time.
///
template<typename T, typename Container>
template<typename T, typename Storage>
class ArrayHandleExecutionManagerBase
{
private:
typedef vtkm::cont::internal::ArrayContainerControl<T,Container>
ContainerType;
typedef vtkm::cont::internal::Storage<T,Storage> StorageType;
public:
template <typename DeviceAdapter>
struct ExecutionTypes
{
private:
typedef vtkm::cont::internal::ArrayTransfer<T,Container,DeviceAdapter>
typedef vtkm::cont::internal::ArrayTransfer<T,Storage,DeviceAdapter>
ArrayTransferType;
public:
typedef typename ArrayTransferType::PortalExecution Portal;
@ -56,8 +56,8 @@ public:
/// An array portal that can be used in the control environment.
///
typedef typename ContainerType::PortalType PortalControl;
typedef typename ContainerType::PortalConstType PortalConstControl;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
VTKM_CONT_EXPORT
virtual ~ArrayHandleExecutionManagerBase() { }
@ -81,31 +81,31 @@ public:
/// arrays, then this method may save the iterators to be returned in the \c
/// GetPortalConst methods.
///
virtual void LoadDataForInput(const ContainerType &controlArray) = 0;
virtual void LoadDataForInput(const StorageType &controlArray) = 0;
/// Allocates a large enough array in the execution environment and copies
/// the given data to that array. The allocated array can later be accessed
/// via the GetPortalExection method. If control and execution share arrays,
/// then this method may save the iterators of the container to be returned
/// then this method may save the iterators of the storage to be returned
/// in the \c GetPortal* methods.
///
virtual void LoadDataForInPlace(ContainerType &controlArray) = 0;
virtual void LoadDataForInPlace(StorageType &controlArray) = 0;
/// Allocates an array in the execution environment of the specified size.
/// If control and execution share arrays, then this class can allocate
/// data using the given ArrayContainerExecution and remember its iterators
/// so that it can be used directly in the execution environment.
/// Allocates an array in the execution environment of the specified size. If
/// control and execution share arrays, then this class can allocate data
/// using the given Storage and remember its iterators so that it can be used
/// directly in the execution environment.
///
virtual void AllocateArrayForOutput(ContainerType &controlArray,
virtual void AllocateArrayForOutput(StorageType &controlArray,
vtkm::Id numberOfValues) = 0;
/// Allocates data in the given ArrayContainerControl and copies data held
/// Allocates data in the given Storage and copies data held
/// in the execution environment (managed by this class) into the control
/// array. If control and execution share arrays, this can be no operation.
/// This method should only be called after AllocateArrayForOutput is
/// called.
///
virtual void RetrieveOutputData(ContainerType &controlArray) const = 0;
virtual void RetrieveOutputData(StorageType &controlArray) const = 0;
/// \brief Reduces the size of the array without changing its values.
///
@ -191,15 +191,15 @@ private:
/// ArrayHandle to change its device at run time.
///
template<typename T,
typename Container,
typename Storage,
typename DeviceAdapter>
class ArrayHandleExecutionManager
: public ArrayHandleExecutionManagerBase<T, Container>
: public ArrayHandleExecutionManagerBase<T, Storage>
{
typedef ArrayHandleExecutionManagerBase<T, Container> Superclass;
typedef vtkm::cont::internal::ArrayTransfer<T,Container,DeviceAdapter>
typedef ArrayHandleExecutionManagerBase<T, Storage> Superclass;
typedef vtkm::cont::internal::ArrayTransfer<T,Storage,DeviceAdapter>
ArrayTransferType;
typedef vtkm::cont::internal::ArrayContainerControl<T,Container> ContainerType;
typedef vtkm::cont::internal::Storage<T,Storage> StorageType;
public:
typedef typename ArrayTransferType::PortalControl PortalControl;
@ -218,25 +218,25 @@ public:
}
VTKM_CONT_EXPORT
void LoadDataForInput(const ContainerType &controlArray)
void LoadDataForInput(const StorageType &controlArray)
{
this->Transfer.LoadDataForInput(controlArray);
}
VTKM_CONT_EXPORT
void LoadDataForInPlace(ContainerType &controlArray)
void LoadDataForInPlace(StorageType &controlArray)
{
this->Transfer.LoadDataForInPlace(controlArray);
}
VTKM_CONT_EXPORT
void AllocateArrayForOutput(ContainerType &controlArray, Id numberOfValues)
void AllocateArrayForOutput(StorageType &controlArray, Id numberOfValues)
{
this->Transfer.AllocateArrayForOutput(controlArray, numberOfValues);
}
VTKM_CONT_EXPORT
void RetrieveOutputData(ContainerType &controlArray) const
void RetrieveOutputData(StorageType &controlArray) const
{
this->Transfer.RetrieveOutputData(controlArray);
}

21
vtkm/cont/internal/ArrayManagerExecution.h
View File

@ -41,17 +41,16 @@ namespace internal {
/// behaves how you would expect. It allocates/deallocates arrays and copies
/// data. However, if the control and execution environments share the same
/// memory space, this class should delegate all its operations to the
/// ArrayContainerControl. The latter can probably be implemented with a
/// \c Storage. The latter can probably be implemented with a
/// trivial subclass of
/// vtkm::cont::internal::ArrayManagerExecutionShareWithControl.
///
template<typename T, class ArrayContainerControlTag, class DeviceAdapterTag>
template<typename T, class StorageTag, class DeviceAdapterTag>
class ArrayManagerExecution
#ifdef VTKM_DOXYGEN_ONLY
{
private:
typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
ContainerType;
typedef vtkm::cont::internal::Storage<T,StorageTag> StorageType;
public:
/// The type of value held in the array (vtkm::Scalar, vtkm::Vector3, etc.)
@ -83,31 +82,31 @@ public:
/// GetPortalConst method.
///
VTKM_CONT_EXPORT void LoadDataForInput(
const typename ContainerType::PortalConstType& portal);
const typename StorageType::PortalConstType& portal);
/// Allocates a large enough array in the execution environment and copies
/// the given data to that array. The allocated array can later be accessed
/// via the GetPortal method. If control and execution share arrays, then
/// this method may save the iterators of the container to be returned in the
/// this method may save the iterators of the storage to be returned in the
/// \c GetPortal* methods.
///
VTKM_CONT_EXPORT void LoadDataForInPlace(PortalType portal);
/// Allocates an array in the execution environment of the specified size.
/// If control and execution share arrays, then this class can allocate
/// data using the given ArrayContainerExecution and remember its iterators
/// data using the given Storage object and remember its iterators
/// so that it can be used directly in the execution environment.
///
VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
vtkm::Id numberOfValues);
VTKM_CONT_EXPORT void AllocateArrayForOutput(StorageType &controlArray,
vtkm::Id numberOfValues);
/// Allocates data in the given ArrayContainerControl and copies data held
/// Allocates data in the given Storage and copies data held
/// in the execution environment (managed by this class) into the control
/// array. If control and execution share arrays, this can be no operation.
/// This method should only be called after AllocateArrayForOutput is
/// called.
///
VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const;
VTKM_CONT_EXPORT void RetrieveOutputData(StorageType &controlArray) const;
/// \brief Reduces the size of the array without changing its values.
///

9
vtkm/cont/internal/ArrayManagerExecutionSerial.h
View File

@ -28,15 +28,14 @@ namespace vtkm {
namespace cont {
namespace internal {
template <typename T, class ArrayContainerControlTag>
class ArrayManagerExecution
<T, ArrayContainerControlTag, vtkm::cont::DeviceAdapterTagSerial>
template <typename T, class StorageTag>
class ArrayManagerExecution<T, StorageTag, vtkm::cont::DeviceAdapterTagSerial>
: public vtkm::cont::internal::ArrayManagerExecutionShareWithControl
<T, ArrayContainerControlTag>
<T, StorageTag>
{
public:
typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl
<T, ArrayContainerControlTag> Superclass;
<T, StorageTag> Superclass;
typedef typename Superclass::ValueType ValueType;
typedef typename Superclass::PortalType PortalType;
typedef typename Superclass::PortalConstType PortalConstType;

28
vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h
View File

@ -23,7 +23,8 @@
#include <vtkm/Types.h>
#include <vtkm/cont/Assert.h>
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayPortalShrink.h>
#include <algorithm>
@ -35,21 +36,18 @@ namespace internal {
/// \c ArrayManagerExecutionShareWithControl provides an implementation for a
/// \c ArrayManagerExecution class for a device adapter when the execution
/// and control environments share memory. This class basically defers all its
/// calls to an \c ArrayContainerControl class and uses the array allocated
/// there.
/// calls to a \c Storage class and uses the array allocated there.
///
template<typename T, class ArrayContainerControlTag>
template<typename T, class StorageTag>
class ArrayManagerExecutionShareWithControl
{
public:
typedef T ValueType;
typedef vtkm::cont::internal
::ArrayContainerControl<ValueType, ArrayContainerControlTag>
ContainerType;
typedef vtkm::cont::internal::Storage<ValueType, StorageTag> StorageType;
typedef vtkm::cont::internal::ArrayPortalShrink<
typename ContainerType::PortalType> PortalType;
typename StorageType::PortalType> PortalType;
typedef vtkm::cont::internal::ArrayPortalShrink<
typename ContainerType::PortalConstType> PortalConstType;
typename StorageType::PortalConstType> PortalConstType;
VTKM_CONT_EXPORT ArrayManagerExecutionShareWithControl()
: PortalValid(false), ConstPortalValid(false) { }
@ -87,8 +85,8 @@ public:
/// Actually just allocates memory in the given \p controlArray.
///
VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
vtkm::Id numberOfValues)
VTKM_CONT_EXPORT void AllocateArrayForOutput(StorageType &controlArray,
vtkm::Id numberOfValues)
{
controlArray.Allocate(numberOfValues);
@ -103,7 +101,7 @@ public:
/// this class's iterators should already be written to the given \c
/// controlArray (under correct operation).
///
VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const
VTKM_CONT_EXPORT void RetrieveOutputData(StorageType &controlArray) const
{
VTKM_ASSERT_CONT(this->ConstPortalValid);
VTKM_ASSERT_CONT(controlArray.GetPortalConst().GetIteratorBegin() ==
@ -124,7 +122,7 @@ public:
}
}
/// Returns the portal previously saved from an \c ArrayContainerControl.
/// Returns the portal previously saved from a \c Storage.
///
VTKM_CONT_EXPORT PortalType GetPortal()
{
@ -147,9 +145,9 @@ public:
private:
// Not implemented.
ArrayManagerExecutionShareWithControl(
ArrayManagerExecutionShareWithControl<T, ArrayContainerControlTag> &);
ArrayManagerExecutionShareWithControl<T, StorageTag> &);
void operator=(
ArrayManagerExecutionShareWithControl<T, ArrayContainerControlTag> &);
ArrayManagerExecutionShareWithControl<T, StorageTag> &);
PortalType Portal;
bool PortalValid;

52
vtkm/cont/internal/ArrayTransfer.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_cont_internal_ArrayTransfer_h
#define vtk_m_cont_internal_ArrayTransfer_h
#include <vtkm/cont/ArrayContainerControl.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/internal/ArrayManagerExecution.h>
namespace vtkm {
@ -37,20 +37,19 @@ namespace internal {
///
/// The primary motivation for having a separate class is that the
/// ArrayManagerExecution is meant to be specialized for each device adapter
/// whee as the ArrayTransfer is meant to be specialized for each array
/// container (or specific combination of container and device adapter). Thus,
/// transfers for most containers will be delegated through the
/// ArrayManagerExecution, but some containers, like implicit containers, will
/// be specialized to transfer through a different path.
/// whereas the ArrayTransfer is meant to be specialized for each storage type
/// (or specific combination of storage and device adapter). Thus, transfers
/// for most storage tyeps will be delegated through the ArrayManagerExecution,
/// but some storage types, like implicit storage, will be specialized to
/// transfer through a different path.
///
template<typename T, class ArrayContainerControlTag, class DeviceAdapterTag>
template<typename T, class StorageTag, class DeviceAdapterTag>
class ArrayTransfer
{
private:
typedef vtkm::cont::internal::ArrayContainerControl<T,ArrayContainerControlTag>
ContainerType;
typedef vtkm::cont::internal::Storage<T,StorageTag> StorageType;
typedef vtkm::cont::internal::ArrayManagerExecution<
T,ArrayContainerControlTag,DeviceAdapterTag> ArrayManagerType;
T,StorageTag,DeviceAdapterTag> ArrayManagerType;
public:
/// The type of value held in the array (vtkm::Scalar, vtkm::Vector3, etc.)
@ -59,8 +58,8 @@ public:
/// An array portal that can be used in the control environment.
///
typedef typename ContainerType::PortalType PortalControl;
typedef typename ContainerType::PortalConstType PortalConstControl;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
/// An array portal that can be used in the execution environment.
///
@ -93,7 +92,7 @@ public:
/// arrays, then this method may save the iterators to be returned in the \c
/// GetPortalConst methods.
///
VTKM_CONT_EXPORT void LoadDataForInput(const ContainerType &controlArray)
VTKM_CONT_EXPORT void LoadDataForInput(const StorageType &controlArray)
{
this->ArrayManager.LoadDataForInput(controlArray.GetPortalConst());
}
@ -101,32 +100,31 @@ public:
/// Allocates a large enough array in the execution environment and copies
/// the given data to that array. The allocated array can later be accessed
/// via the GetPortalExection method. If control and execution share arrays,
/// then this method may save the iterators of the container to be returned
/// then this method may save the iterators of the storage to be returned
/// in the \c GetPortal* methods.
///
VTKM_CONT_EXPORT void LoadDataForInPlace(ContainerType &controlArray)
VTKM_CONT_EXPORT void LoadDataForInPlace(StorageType &controlArray)
{
this->ArrayManager.LoadDataForInPlace(controlArray.GetPortal());
}
/// Allocates an array in the execution environment of the specified size.
/// If control and execution share arrays, then this class can allocate
/// data using the given ArrayContainerExecution and remember its iterators
/// so that it can be used directly in the execution environment.
/// Allocates an array in the execution environment of the specified size. If
/// control and execution share arrays, then this class can allocate data
/// using the given Storage and remember its iterators so that it can be used
/// directly in the execution environment.
///
VTKM_CONT_EXPORT void AllocateArrayForOutput(ContainerType &controlArray,
vtkm::Id numberOfValues)
VTKM_CONT_EXPORT void AllocateArrayForOutput(StorageType &controlArray,
vtkm::Id numberOfValues)
{
this->ArrayManager.AllocateArrayForOutput(controlArray, numberOfValues);
}
/// Allocates data in the given ArrayContainerControl and copies data held
/// in the execution environment (managed by this class) into the control
/// array. If control and execution share arrays, this can be no operation.
/// This method should only be called after AllocateArrayForOutput is
/// called.
/// Allocates data in the given Storage and copies data held in the execution
/// environment (managed by this class) into the control array. If control
/// and execution share arrays, this can be no operation. This method should
/// only be called after AllocateArrayForOutput is called.
///
VTKM_CONT_EXPORT void RetrieveOutputData(ContainerType &controlArray) const
VTKM_CONT_EXPORT void RetrieveOutputData(StorageType &controlArray) const
{
this->ArrayManager.RetrieveOutputData(controlArray);
}

1
vtkm/cont/internal/CMakeLists.txt
View File

@ -36,6 +36,7 @@ set(headers
IteratorFromArrayPortal.h
PointCoordinatesBase.h
SimplePolymorphicContainer.h
StorageError.h
)
vtkm_declare_headers(${headers})

18
vtkm/cont/internal/DeviceAdapterAlgorithm.h
View File

@ -188,18 +188,18 @@ struct DeviceAdapterAlgorithm
/// Sorts the contents of \c values so that they in ascending value. Doesn't
/// guarantee stability
///
template<typename T, class Container>
template<typename T, class Storage>
VTKM_CONT_EXPORT static void Sort(
vtkm::cont::ArrayHandle<T,Container,DeviceAdapterTag> &values);
vtkm::cont::ArrayHandle<T,Storage,DeviceAdapterTag> &values);
/// \brief Unstable ascending sort of input array.
///
/// Sorts the contents of \c values so that they in ascending value based
/// on the custom compare functor.
///
template<typename T, class Container, class Compare>
template<typename T, class Storage, class Compare>
VTKM_CONT_EXPORT static void Sort(
vtkm::cont::ArrayHandle<T,Container,DeviceAdapterTag> &values,
vtkm::cont::ArrayHandle<T,Storage,DeviceAdapterTag> &values,
Compare comp);
/// \brief Performs stream compaction to remove unwanted elements in the input array. Output becomes the index values of input that are valid.
@ -246,9 +246,9 @@ struct DeviceAdapterAlgorithm
/// duplicate values that aren't adjacent. Note the values array size might
/// be modified by this operation.
///
template<typename T, class Container>
template<typename T, class Storage>
VTKM_CONT_EXPORT static void Unique(
vtkm::cont::ArrayHandle<T,Container,DeviceAdapterTag>& values);
vtkm::cont::ArrayHandle<T,Storage,DeviceAdapterTag>& values);
/// \brief Reduce an array to only the unique values it contains
///
@ -260,9 +260,9 @@ struct DeviceAdapterAlgorithm
/// Uses the custom binary predicate Comparison to determine if something
/// is unique. The predicate must return true if the two items are the same.
///
template<typename T, class Container, class Compare>
template<typename T, class Storage, class Compare>
VTKM_CONT_EXPORT static void Unique(
vtkm::cont::ArrayHandle<T,Container,DeviceAdapterTag>& values,
vtkm::cont::ArrayHandle<T,Storage,DeviceAdapterTag>& values,
Compare comp);
/// \brief Output is the last index in input for each item in values that wouldn't alter the ordering of input
@ -353,7 +353,7 @@ public:
vtkm::Scalar elapsedTime;
elapsedTime = vtkm::Scalar(currentTime.Seconds - this->StartTime.Seconds);
elapsedTime +=
elapsedTime +=
(vtkm::Scalar(currentTime.Microseconds - this->StartTime.Microseconds)
/vtkm::Scalar(1000000));

42
vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h
View File

@ -22,7 +22,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/exec/FunctorBase.h>
@ -111,7 +111,7 @@ private:
vtkm::Id index)
{
typedef vtkm::cont::ArrayHandle<T,CIn> InputArrayType;
typedef vtkm::cont::ArrayHandle<T,vtkm::cont::ArrayContainerControlTagBasic>
typedef vtkm::cont::ArrayHandle<T,vtkm::cont::StorageTagBasic>
OutputArrayType;
OutputArrayType output;
@ -353,7 +353,7 @@ public:
const vtkm::cont::ArrayHandle<T,CIn> &input,
vtkm::cont::ArrayHandle<T,COut>& output)
{
typedef vtkm::cont::ArrayHandle<T,vtkm::cont::ArrayContainerControlTagBasic>
typedef vtkm::cont::ArrayHandle<T,vtkm::cont::StorageTagBasic>
TempArrayType;
typedef vtkm::cont::ArrayHandle<T,COut> OutputArrayType;
@ -553,12 +553,12 @@ private:
};
public:
template<typename T, class Container, class CompareType>
template<typename T, class Storage, class CompareType>
VTKM_CONT_EXPORT static void Sort(
vtkm::cont::ArrayHandle<T,Container> &values,
vtkm::cont::ArrayHandle<T,Storage> &values,
CompareType compare)
{
typedef typename vtkm::cont::ArrayHandle<T,Container> ArrayType;
typedef typename vtkm::cont::ArrayHandle<T,Storage> ArrayType;
typedef typename ArrayType::template ExecutionTypes<DeviceAdapterTag>
::Portal PortalType;
@ -588,9 +588,9 @@ public:
}
}
template<typename T, class Container>
template<typename T, class Storage>
VTKM_CONT_EXPORT static void Sort(
vtkm::cont::ArrayHandle<T,Container> &values)
vtkm::cont::ArrayHandle<T,Storage> &values)
{
DerivedAlgorithm::Sort(values, DefaultCompareFunctor());
}
@ -677,7 +677,7 @@ public:
vtkm::Id arrayLength = stencil.GetNumberOfValues();
typedef vtkm::cont::ArrayHandle<
vtkm::Id, vtkm::cont::ArrayContainerControlTagBasic> IndexArrayType;
vtkm::Id, vtkm::cont::StorageTagBasic> IndexArrayType;
IndexArrayType indices;
typedef typename vtkm::cont::ArrayHandle<U,CStencil>
@ -809,22 +809,22 @@ private:
};
public:
template<typename T, class Container>
template<typename T, class Storage>
VTKM_CONT_EXPORT static void Unique(
vtkm::cont::ArrayHandle<T,Container> &values)
vtkm::cont::ArrayHandle<T,Storage> &values)
{
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>
stencilArray;
vtkm::Id inputSize = values.GetNumberOfValues();
ClassifyUniqueKernel<
typename vtkm::cont::ArrayHandle<T,Container>::template ExecutionTypes<DeviceAdapterTag>::PortalConst,
typename vtkm::cont::ArrayHandle<vtkm::Id,vtkm::cont::ArrayContainerControlTagBasic>::template ExecutionTypes<DeviceAdapterTag>::Portal>
typename vtkm::cont::ArrayHandle<T,Storage>::template ExecutionTypes<DeviceAdapterTag>::PortalConst,
typename vtkm::cont::ArrayHandle<vtkm::Id,vtkm::cont::StorageTagBasic>::template ExecutionTypes<DeviceAdapterTag>::Portal>
classifyKernel(values.PrepareForInput(DeviceAdapterTag()),
stencilArray.PrepareForOutput(inputSize, DeviceAdapterTag()));
DerivedAlgorithm::Schedule(classifyKernel, inputSize);
vtkm::cont::ArrayHandle<T, vtkm::cont::ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>
outputArray;
DerivedAlgorithm::StreamCompact(values, stencilArray, outputArray);
@ -832,25 +832,25 @@ public:
DerivedAlgorithm::Copy(outputArray, values);
}
template<typename T, class Container, class Compare>
template<typename T, class Storage, class Compare>
VTKM_CONT_EXPORT static void Unique(
vtkm::cont::ArrayHandle<T,Container> &values,
vtkm::cont::ArrayHandle<T,Storage> &values,
Compare comp)
{
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<vtkm::Id, vtkm::cont::StorageTagBasic>
stencilArray;
vtkm::Id inputSize = values.GetNumberOfValues();
ClassifyUniqueComparisonKernel<
typename vtkm::cont::ArrayHandle<T,Container>::template ExecutionTypes<DeviceAdapterTag>::PortalConst,
typename vtkm::cont::ArrayHandle<vtkm::Id,vtkm::cont::ArrayContainerControlTagBasic>::template ExecutionTypes<DeviceAdapterTag>::Portal,
typename vtkm::cont::ArrayHandle<T,Storage>::template ExecutionTypes<DeviceAdapterTag>::PortalConst,
typename vtkm::cont::ArrayHandle<vtkm::Id,vtkm::cont::StorageTagBasic>::template ExecutionTypes<DeviceAdapterTag>::Portal,
Compare>
classifyKernel(values.PrepareForInput(DeviceAdapterTag()),
stencilArray.PrepareForOutput(inputSize, DeviceAdapterTag()),
comp);
DerivedAlgorithm::Schedule(classifyKernel, inputSize);
vtkm::cont::ArrayHandle<T, vtkm::cont::ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>
outputArray;
DerivedAlgorithm::StreamCompact(values, stencilArray, outputArray);

12
vtkm/cont/internal/DeviceAdapterAlgorithmSerial.h
View File

@ -156,21 +156,21 @@ public:
rangeMax[0] * rangeMax[1] * rangeMax[2] );
}
template<typename T, class Container>
VTKM_CONT_EXPORT static void Sort(vtkm::cont::ArrayHandle<T,Container>& values)
template<typename T, class Storage>
VTKM_CONT_EXPORT static void Sort(vtkm::cont::ArrayHandle<T,Storage>& values)
{
typedef typename vtkm::cont::ArrayHandle<T,Container>
typedef typename vtkm::cont::ArrayHandle<T,Storage>
::template ExecutionTypes<Device>::Portal PortalType;
PortalType arrayPortal = values.PrepareForInPlace(Device());
std::sort(arrayPortal.GetIteratorBegin(), arrayPortal.GetIteratorEnd());
}
template<typename T, class Container, class Compare>
VTKM_CONT_EXPORT static void Sort(vtkm::cont::ArrayHandle<T,Container>& values,
template<typename T, class Storage, class Compare>
VTKM_CONT_EXPORT static void Sort(vtkm::cont::ArrayHandle<T,Storage>& values,
Compare comp)
{
typedef typename vtkm::cont::ArrayHandle<T,Container>
typedef typename vtkm::cont::ArrayHandle<T,Storage>
::template ExecutionTypes<Device>::Portal PortalType;
PortalType arrayPortal = values.PrepareForInPlace(Device());

16
vtkm/cont/internal/ArrayContainerControlError.h → vtkm/cont/internal/StorageError.h
View File

@ -17,20 +17,20 @@
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtkm_cont_internal_ArrayContainerControlError_h
#define vtkm_cont_internal_ArrayContainerControlError_h
#ifndef vtkm_cont_internal_StorageError_h
#define vtkm_cont_internal_StorageError_h
namespace vtkm {
namespace cont {
namespace internal {
/// This is an invalid ArrayContainerControl. The point of this class is to
/// include the header file to make this invalid class the default
/// ArrayContainerControl. From that point, you have to specify an appropriate
/// ArrayContainerControl or else get a compile error.
/// This is an invalid Storage. The point of this class is to include the
/// header file to make this invalid class the default Storage. From that
/// point, you have to specify an appropriate Storage or else get a compile
/// error.
///
struct ArrayContainerControlTagError
struct StorageTagError
{
// Not implemented.
};
@ -39,4 +39,4 @@ struct ArrayContainerControlTagError
}
} // namespace vtkm::cont::internal
#endif //vtkm_cont_internal_ArrayContainerControlError_h
#endif //vtkm_cont_internal_StorageError_h

29
vtkm/cont/internal/testing/UnitTestArrayManagerExecutionShareWithControl.cxx
View File

@ -20,7 +20,8 @@
#include <vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h>
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/testing/Testing.h>
#include <algorithm>
@ -33,14 +34,14 @@ const vtkm::Id ARRAY_SIZE = 10;
template <typename T>
struct TemplatedTests
{
typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl
<T, vtkm::cont::ArrayContainerControlTagBasic>
typedef vtkm::cont::internal::ArrayManagerExecutionShareWithControl<
T, vtkm::cont::StorageTagBasic>
ArrayManagerType;
typedef typename ArrayManagerType::ValueType ValueType;
typedef vtkm::cont::internal::ArrayContainerControl<
T, vtkm::cont::ArrayContainerControlTagBasic> ArrayContainerType;
typedef vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>
StorageType;
void SetContainer(ArrayContainerType &array, const ValueType& value)
void SetStorage(StorageType &array, const ValueType& value)
{
std::fill(array.GetPortal().GetIteratorBegin(),
array.GetPortal().GetIteratorEnd(),
@ -57,7 +58,7 @@ struct TemplatedTests
return true;
}
bool CheckContainer(ArrayContainerType &array, const ValueType& value)
bool CheckStorage(StorageType &array, const ValueType& value)
{
return CheckArray(array.GetPortalConst().GetIteratorBegin(),
array.GetPortalConst().GetIteratorEnd(),
@ -75,9 +76,9 @@ struct TemplatedTests
{
const ValueType INPUT_VALUE(4145);
ArrayContainerType controlArray;
StorageType controlArray;
controlArray.Allocate(ARRAY_SIZE);
SetContainer(controlArray, INPUT_VALUE);
SetStorage(controlArray, INPUT_VALUE);
ArrayManagerType executionArray;
executionArray.LoadDataForInput(controlArray.GetPortalConst());
@ -98,9 +99,9 @@ struct TemplatedTests
{
const ValueType INPUT_VALUE(2350);
ArrayContainerType controlArray;
StorageType controlArray;
controlArray.Allocate(ARRAY_SIZE);
SetContainer(controlArray, INPUT_VALUE);
SetStorage(controlArray, INPUT_VALUE);
ArrayManagerType executionArray;
executionArray.LoadDataForInPlace(controlArray.GetPortal());
@ -125,7 +126,7 @@ struct TemplatedTests
{
const ValueType OUTPUT_VALUE(6712);
ArrayContainerType controlArray;
StorageType controlArray;
ArrayManagerType executionArray;
executionArray.AllocateArrayForOutput(controlArray, ARRAY_SIZE);
@ -139,8 +140,8 @@ struct TemplatedTests
executionArray.RetrieveOutputData(controlArray);
VTKM_TEST_ASSERT(CheckContainer(controlArray, OUTPUT_VALUE),
"Did not get the right value in the control container.");
VTKM_TEST_ASSERT(CheckStorage(controlArray, OUTPUT_VALUE),
"Did not get the right value in the storage.");
}
void operator()()

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

@ -26,13 +26,10 @@ set(headers
vtkm_declare_headers(${headers})
set(unit_tests
UnitTestArrayContainerControlBasic.cxx
UnitTestArrayContainerControlImplicit.cxx
UnitTestArrayHandle.cxx
UnitTestArrayHandleCompositeVector.cxx
UnitTestArrayHandleCounting.cxx
UnitTestArrayHandleUniformPointCoordinates.cxx
UnitTestContainerListTag.cxx
UnitTestContTesting.cxx
UnitTestDeviceAdapterAlgorithmDependency.cxx
UnitTestDeviceAdapterAlgorithmGeneral.cxx
@ -40,6 +37,9 @@ set(unit_tests
UnitTestDynamicArrayHandle.cxx
UnitTestDynamicPointCoordinates.cxx
UnitTestPointCoordinates.cxx
UnitTestStorageBasic.cxx
UnitTestStorageImplicit.cxx
UnitTestStorageListTag.cxx
UnitTestTimer.cxx
)

65
vtkm/cont/testing/TestingDeviceAdapter.h
View File

@ -20,10 +20,10 @@
#ifndef vtk_m_cont_testing_TestingDeviceAdapter_h
#define vtk_m_cont_testing_TestingDeviceAdapter_h
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorControlOutOfMemory.h>
#include <vtkm/cont/ErrorExecution.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/Timer.h>
#include <vtkm/cont/internal/DeviceAdapterAlgorithm.h>
@ -114,27 +114,26 @@ template<class DeviceAdapterTag>
struct TestingDeviceAdapter
{
private:
typedef vtkm::cont::ArrayContainerControlTagBasic ArrayContainerControlTag;
typedef vtkm::cont::StorageTagBasic StorageTag;
typedef vtkm::cont::ArrayHandle<vtkm::Id, ArrayContainerControlTag>
typedef vtkm::cont::ArrayHandle<vtkm::Id, StorageTag>
IdArrayHandle;
typedef vtkm::cont::ArrayHandle<vtkm::Scalar,ArrayContainerControlTag>
typedef vtkm::cont::ArrayHandle<vtkm::Scalar,StorageTag>
ScalarArrayHandle;
typedef vtkm::cont::internal::ArrayManagerExecution<
vtkm::Id, ArrayContainerControlTag, DeviceAdapterTag>
vtkm::Id, StorageTag, DeviceAdapterTag>
IdArrayManagerExecution;
typedef vtkm::cont::internal::ArrayContainerControl<vtkm::Id,
ArrayContainerControlTag> IdContainer;
typedef vtkm::cont::internal::Storage<vtkm::Id, StorageTag> IdStorage;
typedef typename IdArrayHandle::template ExecutionTypes<DeviceAdapterTag>
::Portal IdPortalType;
typedef typename IdArrayHandle::template ExecutionTypes<DeviceAdapterTag>
::PortalConst IdPortalConstType;
typedef vtkm::cont::ArrayHandle<vtkm::Vector3,ArrayContainerControlTag>
typedef vtkm::cont::ArrayHandle<vtkm::Vector3,StorageTag>
Vector3ArrayHandle;
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapterTag>
@ -315,21 +314,21 @@ private:
template<typename T>
static VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<T, StorageTagBasic>
MakeArrayHandle(const T *array, vtkm::Id length)
{
return vtkm::cont::make_ArrayHandle(array,
length,
ArrayContainerControlTagBasic());
StorageTagBasic());
}
template<typename T>
static VTKM_CONT_EXPORT
vtkm::cont::ArrayHandle<T, ArrayContainerControlTagBasic>
vtkm::cont::ArrayHandle<T, StorageTagBasic>
MakeArrayHandle(const std::vector<T>& array)
{
return vtkm::cont::make_ArrayHandle(array,
ArrayContainerControlTagBasic());
StorageTagBasic());
}
static VTKM_CONT_EXPORT void TestDeviceAdapterTag()
@ -357,7 +356,7 @@ private:
std::cout << "Testing ArrayManagerExecution" << std::endl;
typedef vtkm::cont::internal::ArrayManagerExecution<
vtkm::Scalar,ArrayContainerControlTagBasic,DeviceAdapterTag>
vtkm::Scalar,StorageTagBasic,DeviceAdapterTag>
ArrayManagerExecution;
// Create original input array.
@ -401,10 +400,10 @@ private:
{
std::cout << "Do array allocation that should fail." << std::endl;
vtkm::cont::internal::ArrayManagerExecution<
vtkm::Vector4,ArrayContainerControlTagBasic,DeviceAdapterTag>
vtkm::Vector4,StorageTagBasic,DeviceAdapterTag>
bigManager;
vtkm::cont::internal::ArrayContainerControl<
vtkm::Vector4, ArrayContainerControlTagBasic> supportArray;
vtkm::cont::internal::Storage<
vtkm::Vector4, StorageTagBasic> supportArray;
const vtkm::Id bigSize = 0x7FFFFFFFFFFFFFFFLL;
bigManager.AllocateArrayForOutput(supportArray, bigSize);
// It does not seem reasonable to get here. The previous call should fail.
@ -453,9 +452,9 @@ private:
{
std::cout << "Allocating execution array" << std::endl;
IdContainer container;
IdStorage storage;
IdArrayManagerExecution manager;
manager.AllocateArrayForOutput(container, 1);
manager.AllocateArrayForOutput(storage, 1);
std::cout << "Running clear." << std::endl;
Algorithm::Schedule(ClearArrayKernel(manager.GetPortal()), 1);
@ -464,11 +463,11 @@ private:
Algorithm::Schedule(AddArrayKernel(manager.GetPortal()), 1);
std::cout << "Checking results." << std::endl;
manager.RetrieveOutputData(container);
manager.RetrieveOutputData(storage);
for (vtkm::Id index = 0; index < 1; index++)
{
vtkm::Id value = container.GetPortalConst().Get(index);
vtkm::Id value = storage.GetPortalConst().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET,
"Got bad value for single value scheduled kernel.");
}
@ -479,9 +478,9 @@ private:
{
std::cout << "Allocating execution array" << std::endl;
IdContainer container;
IdStorage storage;
IdArrayManagerExecution manager;
manager.AllocateArrayForOutput(container, ARRAY_SIZE);
manager.AllocateArrayForOutput(storage, ARRAY_SIZE);
std::cout << "Running clear." << std::endl;
Algorithm::Schedule(ClearArrayKernel(manager.GetPortal()), ARRAY_SIZE);
@ -490,11 +489,11 @@ private:
Algorithm::Schedule(AddArrayKernel(manager.GetPortal()), ARRAY_SIZE);
std::cout << "Checking results." << std::endl;
manager.RetrieveOutputData(container);
manager.RetrieveOutputData(storage);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
vtkm::Id value = container.GetPortalConst().Get(index);
vtkm::Id value = storage.GetPortalConst().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET,
"Got bad value for scheduled kernels.");
}
@ -506,10 +505,10 @@ private:
{
std::cout << "Allocating execution array" << std::endl;
IdContainer container;
IdStorage storage;
IdArrayManagerExecution manager;
vtkm::Id DIM_SIZE = vtkm::Id(std::pow(ARRAY_SIZE, 1/3.0f));
manager.AllocateArrayForOutput(container,
manager.AllocateArrayForOutput(storage,
DIM_SIZE * DIM_SIZE * DIM_SIZE);
vtkm::Id3 maxRange(DIM_SIZE);
@ -520,12 +519,12 @@ private:
Algorithm::Schedule(AddArrayKernel(manager.GetPortal()), maxRange);
std::cout << "Checking results." << std::endl;
manager.RetrieveOutputData(container);
manager.RetrieveOutputData(storage);
const vtkm::Id maxId = DIM_SIZE * DIM_SIZE * DIM_SIZE;
for (vtkm::Id index = 0; index < maxId; index++)
{
vtkm::Id value = container.GetPortalConst().Get(index);
vtkm::Id value = storage.GetPortalConst().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET,
"Got bad value for scheduled vtkm::Id3 kernels.");
}
@ -1111,7 +1110,7 @@ private:
// //use a scoped pointer that constructs and fills a grid of the
// //right type
// vtkm::cont::testing::TestGrid<GridType,ArrayContainerControlTagBasic>
// vtkm::cont::testing::TestGrid<GridType,StorageTagBasic>
// grid(DIM);
// vtkm::Vector3 trueGradient = vtkm::make_Vector3(1.0, 1.0, 1.0);
@ -1157,7 +1156,7 @@ private:
// std::cout << "-------------------------------------------" << std::endl;
// std::cout << "Testing map field worklet error" << std::endl;
// vtkm::cont::testing::TestGrid<GridType,ArrayContainerControlTagBasic>
// vtkm::cont::testing::TestGrid<GridType,StorageTagBasic>
// grid(DIM);
// std::cout << "Running field map worklet that errors" << std::endl;
@ -1201,7 +1200,7 @@ private:
// template<typename GridType>
// static VTKM_CONT_EXPORT void TestWorkletMapCellImpl()
// {
// vtkm::cont::testing::TestGrid<GridType,ArrayContainerControlTagBasic>
// vtkm::cont::testing::TestGrid<GridType,StorageTagBasic>
// grid(DIM);
// vtkm::Vector3 trueGradient = vtkm::make_Vector3(1.0, 1.0, 1.0);
@ -1247,7 +1246,7 @@ private:
// std::cout << "-------------------------------------------" << std::endl;
// std::cout << "Testing map cell worklet error" << std::endl;
// vtkm::cont::testing::TestGrid<GridType,ArrayContainerControlTagBasic>
// vtkm::cont::testing::TestGrid<GridType,StorageTagBasic>
// grid(DIM);
// std::cout << "Running cell map worklet that errors" << std::endl;
@ -1306,7 +1305,7 @@ private:
// std::cout << "Doing Worklet tests with all grid type" << std::endl;
// vtkm::cont::testing::GridTesting::TryAllGridTypes(
// TestWorklets(), ArrayContainerControlTagBasic());
// TestWorklets(), StorageTagBasic());
}
};

2
vtkm/cont/testing/UnitTestArrayHandle.cxx
View File

@ -20,7 +20,7 @@
//This sets up the ArrayHandle semantics to allocate pointers and share memory
//between control and execution.
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_BASIC
#define VTKM_STORAGE VTKM_STORAGE_BASIC
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_SERIAL
#include <vtkm/cont/ArrayHandle.h>

40
vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx
View File

@ -18,17 +18,17 @@
// this software.
//============================================================================
// Make sure ArrayHandleCompositeVector does not rely on default container or
// Make sure ArrayHandleCompositeVector does not rely on default storage or
// device adapter.
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
#define VTKM_STORAGE VTKM_STORAGE_ERROR
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_ERROR
#include <vtkm/cont/ArrayHandleCompositeVector.h>
#include <vtkm/VectorTraits.h>
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/DeviceAdapterSerial.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/testing/Testing.h>
@ -38,7 +38,7 @@ namespace {
const vtkm::Id ARRAY_SIZE = 10;
typedef vtkm::cont::ArrayContainerControlTagBasic Container;
typedef vtkm::cont::StorageTagBasic StorageTag;
vtkm::Scalar TestValue(vtkm::Id index, int inComponentIndex, int inArrayId)
{
@ -46,7 +46,7 @@ vtkm::Scalar TestValue(vtkm::Id index, int inComponentIndex, int inArrayId)
}
template<typename ValueType>
vtkm::cont::ArrayHandle<ValueType, Container>
vtkm::cont::ArrayHandle<ValueType, StorageTag>
MakeInputArray(int arrayId)
{
typedef vtkm::VectorTraits<ValueType> VTraits;
@ -66,9 +66,9 @@ MakeInputArray(int arrayId)
}
// Make an array handle that points to this buffer.
typedef vtkm::cont::ArrayHandle<ValueType, Container> ArrayHandleType;
typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> ArrayHandleType;
ArrayHandleType bufferHandle =
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, Container());
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, StorageTag());
// When this function returns, the array is going to go out of scope, which
// will invalidate the array handle we just created. So copy to a new buffer
@ -87,7 +87,7 @@ void CheckArray(const vtkm::cont::ArrayHandle<ValueType,C> &outArray,
{
// ArrayHandleCompositeVector currently does not implement the ability to
// get to values on the control side, so copy to an array that is accessible.
typedef vtkm::cont::ArrayHandle<ValueType, Container> ArrayHandleType;
typedef vtkm::cont::ArrayHandle<ValueType, StorageTag> ArrayHandleType;
ArrayHandleType arrayCopy;
vtkm::cont::DeviceAdapterAlgorithm<vtkm::cont::DeviceAdapterTagSerial>::Copy(
outArray, arrayCopy);
@ -120,7 +120,7 @@ void TryScalarArray()
<< inComponents << " components." << std::endl;
typedef vtkm::Tuple<vtkm::Scalar,inComponents> InValueType;
typedef vtkm::cont::ArrayHandle<InValueType, Container> InArrayType;
typedef vtkm::cont::ArrayHandle<InValueType, StorageTag> InArrayType;
int inArrayId = 0;
InArrayType inArray = MakeInputArray<InValueType>(inArrayId);
@ -137,10 +137,10 @@ void TryScalarArray()
}
template<typename T1, typename T2, typename T3, typename T4>
void TryVector4(vtkm::cont::ArrayHandle<T1,Container> array1,
vtkm::cont::ArrayHandle<T2,Container> array2,
vtkm::cont::ArrayHandle<T3,Container> array3,
vtkm::cont::ArrayHandle<T4,Container> array4)
void TryVector4(vtkm::cont::ArrayHandle<T1,StorageTag> array1,
vtkm::cont::ArrayHandle<T2,StorageTag> array2,
vtkm::cont::ArrayHandle<T3,StorageTag> array3,
vtkm::cont::ArrayHandle<T4,StorageTag> array4)
{
int arrayIds[4] = {0, 1, 2, 3};
int inComponents[4];
@ -176,9 +176,9 @@ void TryVector4(vtkm::cont::ArrayHandle<T1,Container> array1,
}
template<typename T1, typename T2, typename T3>
void TryVector3(vtkm::cont::ArrayHandle<T1,Container> array1,
vtkm::cont::ArrayHandle<T2,Container> array2,
vtkm::cont::ArrayHandle<T3,Container> array3)
void TryVector3(vtkm::cont::ArrayHandle<T1,StorageTag> array1,
vtkm::cont::ArrayHandle<T2,StorageTag> array2,
vtkm::cont::ArrayHandle<T3,StorageTag> array3)
{
int arrayIds[3] = {0, 1, 2};
int inComponents[3];
@ -213,8 +213,8 @@ void TryVector3(vtkm::cont::ArrayHandle<T1,Container> array1,
}
template<typename T1, typename T2>
void TryVector2(vtkm::cont::ArrayHandle<T1,Container> array1,
vtkm::cont::ArrayHandle<T2,Container> array2)
void TryVector2(vtkm::cont::ArrayHandle<T1,StorageTag> array1,
vtkm::cont::ArrayHandle<T2,StorageTag> array2)
{
int arrayIds[2] = {0, 1};
int inComponents[2];
@ -243,7 +243,7 @@ void TryVector2(vtkm::cont::ArrayHandle<T1,Container> array1,
}
template<typename T1>
void TryVector1(vtkm::cont::ArrayHandle<T1,Container> array1)
void TryVector1(vtkm::cont::ArrayHandle<T1,StorageTag> array1)
{
int arrayIds[1] = {0};
int inComponents[1];
@ -278,7 +278,7 @@ void TestBadArrayLengths() {
std::cout << "Checking behavior when size of input arrays do not agree."
<< std::endl;
typedef vtkm::cont::ArrayHandle<vtkm::Scalar, Container> InArrayType;
typedef vtkm::cont::ArrayHandle<vtkm::Scalar, StorageTag> InArrayType;
InArrayType longInArray = MakeInputArray<vtkm::Scalar>(0);
InArrayType shortInArray = MakeInputArray<vtkm::Scalar>(1);
shortInArray.Shrink(ARRAY_SIZE/2);

10
vtkm/cont/testing/UnitTestDeviceAdapterAlgorithmGeneral.cxx
View File

@ -77,17 +77,15 @@ public:
namespace internal {
template <typename T, class ArrayContainerControlTag>
template <typename T, class StorageTag>
class ArrayManagerExecution
<T,
ArrayContainerControlTag,
vtkm::cont::DeviceAdapterTagTestAlgorithmGeneral>
<T, StorageTag, vtkm::cont::DeviceAdapterTagTestAlgorithmGeneral>
: public vtkm::cont::internal::ArrayManagerExecution
<T, ArrayContainerControlTag, vtkm::cont::DeviceAdapterTagSerial>
<T, StorageTag, vtkm::cont::DeviceAdapterTagSerial>
{
public:
typedef vtkm::cont::internal::ArrayManagerExecution
<T, ArrayContainerControlTag, vtkm::cont::DeviceAdapterTagSerial>
<T, StorageTag, vtkm::cont::DeviceAdapterTagSerial>
Superclass;
typedef typename Superclass::ValueType ValueType;
typedef typename Superclass::PortalType PortalType;

65
vtkm/cont/testing/UnitTestDynamicArrayHandle.cxx
View File

@ -21,7 +21,8 @@
#include <vtkm/cont/DynamicArrayHandle.h>
#include <vtkm/cont/ArrayContainerControlImplicit.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
#include <vtkm/cont/testing/Testing.h>
@ -85,35 +86,35 @@ struct UnusualPortal
};
template<typename T>
class ArrayHandleWithUnusualContainer
: public vtkm::cont::ArrayHandle<T, vtkm::cont::ArrayContainerControlTagImplicit<UnusualPortal<T> > >
class ArrayHandleWithUnusualStorage
: public vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T> > >
{
typedef vtkm::cont::ArrayHandle<T, vtkm::cont::ArrayContainerControlTagImplicit<UnusualPortal<T> > >
typedef vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagImplicit<UnusualPortal<T> > >
Superclass;
public:
VTKM_CONT_EXPORT
ArrayHandleWithUnusualContainer()
ArrayHandleWithUnusualStorage()
: Superclass(typename Superclass::PortalConstControl()) { }
};
struct ContainerListTagUnusual :
struct StorageListTagUnusual :
vtkm::ListTagBase2<
ArrayHandleWithUnusualContainer<vtkm::Id>::ArrayContainerControlTag,
ArrayHandleWithUnusualContainer<std::string>::ArrayContainerControlTag>
ArrayHandleWithUnusualStorage<vtkm::Id>::StorageTag,
ArrayHandleWithUnusualStorage<std::string>::StorageTag>
{ };
bool CheckCalled;
struct CheckFunctor
{
template<typename T, typename Container>
void operator()(vtkm::cont::ArrayHandle<T, Container> array) const {
template<typename T, typename Storage>
void operator()(vtkm::cont::ArrayHandle<T, Storage> array) const {
CheckCalled = true;
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE,
"Unexpected array size.");
typename vtkm::cont::ArrayHandle<T,Container>::PortalConstControl portal =
typename vtkm::cont::ArrayHandle<T,Storage>::PortalConstControl portal =
array.GetPortalConstControl();
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
@ -187,58 +188,58 @@ void TryUnusualType()
std::cout << " Found type when type list was reset." << std:: endl;
}
void TryUnusualContainer()
void TryUnusualStorage()
{
vtkm::cont::DynamicArrayHandle array =
ArrayHandleWithUnusualContainer<vtkm::Id>();
ArrayHandleWithUnusualStorage<vtkm::Id>();
try
{
array.CastAndCall(CheckFunctor());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized container.");
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
{
std::cout << " Caught exception for unrecognized container." << std::endl;
std::cout << " Caught exception for unrecognized storage." << std::endl;
}
CheckCalled = false;
array.ResetContainerList(ContainerListTagUnusual()).CastAndCall(CheckFunctor());
array.ResetStorageList(StorageListTagUnusual()).CastAndCall(CheckFunctor());
VTKM_TEST_ASSERT(CheckCalled,
"The functor was never called (and apparently a bad value exception not thrown).");
std::cout << " Found instance when container list was reset." << std:: endl;
std::cout << " Found instance when storage list was reset." << std:: endl;
}
void TryUnusualTypeAndContainer()
void TryUnusualTypeAndStorage()
{
vtkm::cont::DynamicArrayHandle array =
ArrayHandleWithUnusualContainer<std::string>();
ArrayHandleWithUnusualStorage<std::string>();
try
{
array.CastAndCall(CheckFunctor());
VTKM_TEST_FAIL(
"CastAndCall failed to error for unrecognized type/container.");
"CastAndCall failed to error for unrecognized type/storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
{
std::cout << " Caught exception for unrecognized type/container."
std::cout << " Caught exception for unrecognized type/storage."
<< std::endl;
}
try
{
array.ResetTypeList(TypeListTagString()).CastAndCall(CheckFunctor());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized container.");
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue)
{
std::cout << " Caught exception for unrecognized container." << std::endl;
std::cout << " Caught exception for unrecognized storage." << std::endl;
}
try
{
array.ResetContainerList(ContainerListTagUnusual()).
array.ResetStorageList(StorageListTagUnusual()).
CastAndCall(CheckFunctor());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized type.");
}
@ -250,20 +251,20 @@ void TryUnusualTypeAndContainer()
CheckCalled = false;
array
.ResetTypeList(TypeListTagString())
.ResetContainerList(ContainerListTagUnusual())
.ResetStorageList(StorageListTagUnusual())
.CastAndCall(CheckFunctor());
VTKM_TEST_ASSERT(CheckCalled,
"The functor was never called (and apparently a bad value exception not thrown).");
std::cout << " Found instance when type and container lists were reset." << std:: endl;
std::cout << " Found instance when type and storage lists were reset." << std:: endl;
CheckCalled = false;
array
.ResetContainerList(ContainerListTagUnusual())
.ResetStorageList(StorageListTagUnusual())
.ResetTypeList(TypeListTagString())
.CastAndCall(CheckFunctor());
VTKM_TEST_ASSERT(CheckCalled,
"The functor was never called (and apparently a bad value exception not thrown).");
std::cout << " Found instance when container and type lists were reset." << std:: endl;
std::cout << " Found instance when storage and type lists were reset." << std:: endl;
}
void TestDynamicArrayHandle()
@ -279,11 +280,11 @@ void TestDynamicArrayHandle()
std::cout << "Try unusual type." << std::endl;
TryUnusualType();
std::cout << "Try unusual container." << std::endl;
TryUnusualContainer();
std::cout << "Try unusual storage." << std::endl;
TryUnusualStorage();
std::cout << "Try unusual type in unusual container." << std::endl;
TryUnusualTypeAndContainer();
std::cout << "Try unusual type in unusual storage." << std::endl;
TryUnusualTypeAndStorage();
}
} // anonymous namespace

52
vtkm/cont/testing/UnitTestDynamicPointCoordinates.cxx
View File

@ -20,8 +20,8 @@
#include <vtkm/cont/DynamicPointCoordinates.h>
#include <vtkm/cont/ArrayContainerControlImplicit.h>
#include <vtkm/cont/ContainerListTag.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/StorageListTag.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
@ -42,7 +42,7 @@ vtkm::Vector3 TestValue(vtkm::Id index)
{
vtkm::Id3 index3d = vtkm::ExtentPointFlatIndexToTopologyIndex(index, EXTENT);
return vtkm::Vector3(vtkm::Scalar(index3d[0]),
vtkm::Scalar(index3d[1]),
vtkm::Scalar(index3d[1]),
vtkm::Scalar(index3d[2]));
}
@ -54,13 +54,13 @@ struct CheckArray
g_CheckArrayInvocations = 0;
}
template<typename Container>
template<typename Storage>
void operator()(
const vtkm::cont::ArrayHandle<vtkm::Vector3,Container> &array) const
const vtkm::cont::ArrayHandle<vtkm::Vector3,Storage> &array) const
{
std::cout << " In CastAndCall functor" << std::endl;
g_CheckArrayInvocations++;
typename vtkm::cont::ArrayHandle<vtkm::Vector3,Container>::PortalConstControl portal =
typename vtkm::cont::ArrayHandle<vtkm::Vector3,Storage>::PortalConstControl portal =
array.GetPortalConstControl();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,
@ -100,27 +100,27 @@ struct UnusualPortal
}
};
class ArrayHandleWithUnusualContainer
: public vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::ArrayContainerControlTagImplicit<UnusualPortal> >
class ArrayHandleWithUnusualStorage
: public vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::StorageTagImplicit<UnusualPortal> >
{
typedef vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::ArrayContainerControlTagImplicit<UnusualPortal> >
typedef vtkm::cont::ArrayHandle<vtkm::Vector3, vtkm::cont::StorageTagImplicit<UnusualPortal> >
Superclass;
public:
VTKM_CONT_EXPORT
ArrayHandleWithUnusualContainer()
ArrayHandleWithUnusualStorage()
: Superclass(Superclass::PortalConstControl()) { }
};
struct ContainerListTagUnusual :
vtkm::ListTagBase<ArrayHandleWithUnusualContainer::ArrayContainerControlTag>
struct StorageListTagUnusual :
vtkm::ListTagBase<ArrayHandleWithUnusualStorage::StorageTag>
{ };
struct PointCoordinatesUnusual : vtkm::cont::internal::PointCoordinatesBase
{
template<typename Functor, typename TypeList, typename ContainerList>
void CastAndCall(const Functor &f, TypeList, ContainerList) const
template<typename Functor, typename TypeList, typename StorageList>
void CastAndCall(const Functor &f, TypeList, StorageList) const
{
f(ArrayHandleWithUnusualContainer());
f(ArrayHandleWithUnusualStorage());
}
};
@ -129,7 +129,7 @@ struct PointCoordinatesListUnusual
void TryDefaultArray()
{
std::cout << "Trying a basic point coordinates array with a default container."
std::cout << "Trying a basic point coordinates array with a default storage."
<< std::endl;
std::vector<vtkm::Vector3> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
@ -147,30 +147,30 @@ void TryDefaultArray()
"CastAndCall functor not called expected number of times.");
}
void TryUnusualContainer()
void TryUnusualStorage()
{
std::cout << "Trying a basic point coordinates array with an unusual container."
std::cout << "Trying a basic point coordinates array with an unusual storage."
<< std::endl;
vtkm::cont::DynamicPointCoordinates pointCoordinates =
vtkm::cont::DynamicPointCoordinates(
vtkm::cont::PointCoordinatesArray(ArrayHandleWithUnusualContainer()));
vtkm::cont::PointCoordinatesArray(ArrayHandleWithUnusualStorage()));
std::cout << " Make sure we get an exception when we can't find the type."
<< std::endl;
try
{
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized container.");
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
std::cout << " Caught expected exception for unrecognized container: "
std::cout << " Caught expected exception for unrecognized storage: "
<< std::endl << " " << error.GetMessage() << std::endl;
}
std::cout << " Recast containers and try again." << std::endl;
pointCoordinates.ResetContainerList(ContainerListTagUnusual())
std::cout << " Recast storage and try again." << std::endl;
pointCoordinates.ResetStorageList(StorageListTagUnusual())
.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
"CastAndCall functor not called expected number of times.");
@ -202,7 +202,7 @@ void TryUnusualPointCoordinates()
try
{
pointCoordinates.CastAndCall(CheckArray());
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized container.");
VTKM_TEST_FAIL("CastAndCall failed to error for unrecognized storage.");
}
catch (vtkm::cont::ErrorControlBadValue error)
{
@ -210,7 +210,7 @@ void TryUnusualPointCoordinates()
<< std::endl << " " << error.GetMessage() << std::endl;
}
std::cout << " Recast containers and try again." << std::endl;
std::cout << " Recast storage and try again." << std::endl;
pointCoordinates.ResetPointCoordinatesList(PointCoordinatesListUnusual())
.CastAndCall(CheckArray());
VTKM_TEST_ASSERT(g_CheckArrayInvocations == 1,
@ -220,7 +220,7 @@ void TryUnusualPointCoordinates()
void DynamicPointCoordiantesTest()
{
TryDefaultArray();
TryUnusualContainer();
TryUnusualStorage();
TryUniformPointCoordinates();
TryUnusualPointCoordinates();
}

18
vtkm/cont/testing/UnitTestPointCoordinates.cxx
View File

@ -18,13 +18,13 @@
// this software.
//============================================================================
// Make sure nothing relies on default container or device adapter.
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
// Make sure nothing relies on default storage or device adapter.
#define VTKM_STORAGE VTKM_STORAGE_ERROR
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_ERROR
// Make sure nothing relies on default lists.
#define VTKM_DEFAULT_TYPE_LIST_TAG ::vtkm::ListTagEmpty
#define VTKM_DEFAULT_CONTAINER_LIST_TAG ::vtkm::ListTagEmpty
#define VTKM_DEFAULT_STORAGE_LIST_TAG ::vtkm::ListTagEmpty
#include <vtkm/cont/PointCoordinatesArray.h>
#include <vtkm/cont/PointCoordinatesUniform.h>
@ -32,8 +32,8 @@
#include <vtkm/Extent.h>
#include <vtkm/TypeListTag.h>
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/DeviceAdapterSerial.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/testing/Testing.h>
@ -48,9 +48,9 @@ const vtkm::Vector3 SPACING = vtkm::Vector3(1, 1, 1);
const vtkm::Id3 DIMENSION = vtkm::ExtentPointDimensions(EXTENT);
const vtkm::Id ARRAY_SIZE = DIMENSION[0]*DIMENSION[1]*DIMENSION[2];
typedef vtkm::cont::ArrayContainerControlTagBasic Container;
typedef vtkm::cont::StorageTagBasic StorageTag;
struct ContainerListTag : vtkm::cont::ContainerListTagBasic { };
struct StorageListTag : vtkm::cont::StorageListTagBasic { };
vtkm::Vector3 TestValue(vtkm::Id index)
{
@ -95,8 +95,8 @@ void TestPointCoordinatesArray()
}
std::cout << " Creating and checking array handle" << std::endl;
vtkm::cont::ArrayHandle<vtkm::Vector3,Container> array =
vtkm::cont::make_ArrayHandle(buffer, Container());
vtkm::cont::ArrayHandle<vtkm::Vector3,StorageTag> array =
vtkm::cont::make_ArrayHandle(buffer, StorageTag());
CheckArray()(array);
std::cout << " Creating and checking PointCoordinatesArray" << std::endl;
@ -105,7 +105,7 @@ void TestPointCoordinatesArray()
pointCoordinates.CastAndCall(
CheckArray(),
vtkm::ListTagEmpty(), // Internally sets to Vector3
vtkm::cont::ContainerListTagBasic());
vtkm::cont::StorageListTagBasic());
}
void TestPointCoordinatesUniform()

54
vtkm/cont/testing/UnitTestArrayContainerControlBasic.cxx → vtkm/cont/testing/UnitTestStorageBasic.cxx
View File

@ -18,9 +18,9 @@
// this software.
//============================================================================
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
#define VTKM_STORAGE VTKM_STORAGE_ERROR
#include <vtkm/cont/ArrayContainerControlBasic.h>
#include <vtkm/cont/StorageBasic.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/VectorTraits.h>
@ -32,13 +32,13 @@ const vtkm::Id ARRAY_SIZE = 10;
template <typename T>
struct TemplatedTests
{
typedef vtkm::cont::internal::ArrayContainerControl<
T, vtkm::cont::ArrayContainerControlTagBasic> ArrayContainerType;
typedef typename ArrayContainerType::ValueType ValueType;
typedef typename ArrayContainerType::PortalType PortalType;
typedef vtkm::cont::internal::Storage<T, vtkm::cont::StorageTagBasic>
StorageType;
typedef typename StorageType::ValueType ValueType;
typedef typename StorageType::PortalType PortalType;
typedef typename PortalType::IteratorType IteratorType;
void SetContainer(ArrayContainerType &array, const ValueType& value)
void SetStorage(StorageType &array, const ValueType& value)
{
for (IteratorType iter = array.GetPortal().GetIteratorBegin();
iter != array.GetPortal().GetIteratorEnd();
@ -48,7 +48,7 @@ struct TemplatedTests
}
}
bool CheckContainer(ArrayContainerType &array, const ValueType& value)
bool CheckStorage(StorageType &array, const ValueType& value)
{
for (IteratorType iter = array.GetPortal().GetIteratorBegin();
iter != array.GetPortal().GetIteratorEnd();
@ -73,9 +73,9 @@ struct TemplatedTests
ValueType stolenArrayValue = ValueType(STOLEN_ARRAY_VALUE());
ArrayContainerType stealMyArray;
StorageType stealMyArray;
stealMyArray.Allocate(ARRAY_SIZE);
SetContainer(stealMyArray, stolenArrayValue);
SetStorage(stealMyArray, stolenArrayValue);
VTKM_TEST_ASSERT(stealMyArray.GetNumberOfValues() == ARRAY_SIZE,
"Array not properly allocated.");
@ -100,34 +100,34 @@ struct TemplatedTests
void BasicAllocation()
{
ArrayContainerType arrayContainer;
VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == 0,
"New array container not zero sized.");
StorageType arrayStorage;
VTKM_TEST_ASSERT(arrayStorage.GetNumberOfValues() == 0,
"New array storage not zero sized.");
arrayContainer.Allocate(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE,
arrayStorage.Allocate(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayStorage.GetNumberOfValues() == ARRAY_SIZE,
"Array not properly allocated.");
const ValueType BASIC_ALLOC_VALUE = ValueType(548);
SetContainer(arrayContainer, BASIC_ALLOC_VALUE);
VTKM_TEST_ASSERT(CheckContainer(arrayContainer, BASIC_ALLOC_VALUE),
SetStorage(arrayStorage, BASIC_ALLOC_VALUE);
VTKM_TEST_ASSERT(CheckStorage(arrayStorage, BASIC_ALLOC_VALUE),
"Array not holding value.");
arrayContainer.Allocate(ARRAY_SIZE * 2);
VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE * 2,
arrayStorage.Allocate(ARRAY_SIZE * 2);
VTKM_TEST_ASSERT(arrayStorage.GetNumberOfValues() == ARRAY_SIZE * 2,
"Array not reallocated correctly.");
arrayContainer.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == ARRAY_SIZE,
arrayStorage.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(arrayStorage.GetNumberOfValues() == ARRAY_SIZE,
"Array Shrnk failed to resize.");
arrayContainer.ReleaseResources();
VTKM_TEST_ASSERT(arrayContainer.GetNumberOfValues() == 0,
arrayStorage.ReleaseResources();
VTKM_TEST_ASSERT(arrayStorage.GetNumberOfValues() == 0,
"Array not released correctly.");
try
{
arrayContainer.Shrink(ARRAY_SIZE);
arrayStorage.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(true==false,
"Array shrink do a larger size was possible. This can't be allowed.");
}
@ -155,14 +155,14 @@ struct TestFunctor
}
};
void TestArrayContainerControlBasic()
void TestStorageBasic()
{
vtkm::testing::Testing::TryAllTypes(TestFunctor());
}
} // Anonymous namespace
int UnitTestArrayContainerControlBasic(int, char *[])
int UnitTestStorageBasic(int, char *[])
{
return vtkm::cont::testing::Testing::Run(TestArrayContainerControlBasic);
return vtkm::cont::testing::Testing::Run(TestStorageBasic);
}

55
vtkm/cont/testing/UnitTestArrayContainerControlImplicit.cxx → vtkm/cont/testing/UnitTestStorageImplicit.cxx
View File

@ -18,29 +18,31 @@
// this software.
//============================================================================
#define VTKM_ARRAY_CONTAINER_CONTROL VTKM_ARRAY_CONTAINER_CONTROL_ERROR
#define VTKM_STORAGE VTKM_STORAGE_ERROR
#include <vtkm/Types.h>
#include <vtkm/cont/ArrayContainerControlImplicit.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/VectorTraits.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/StorageImplicit.h>
#include <vtkm/cont/internal/IteratorFromArrayPortal.h>
#include <vtkm/cont/testing/Testing.h>
namespace {
template <typename T>
struct TestImplicitContainer
struct TestImplicitStorage
{
typedef T ValueType;
ValueType Temp;
typedef vtkm::cont::internal::IteratorFromArrayPortal<
TestImplicitContainer<T> > IteratorType;
TestImplicitStorage<T> > IteratorType;
VTKM_EXEC_CONT_EXPORT
TestImplicitContainer(): Temp(1) { }
TestImplicitStorage(): Temp(1) { }
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const
@ -74,38 +76,37 @@ const vtkm::Id ARRAY_SIZE = 1;
template <typename T>
struct TemplatedTests
{
typedef vtkm::cont::ArrayContainerControlTagImplicit<
TestImplicitContainer<T> > ContainerTagType;
typedef vtkm::cont::internal::ArrayContainerControl<
T, ContainerTagType > ArrayContainerType;
typedef vtkm::cont::StorageTagImplicit< TestImplicitStorage<T> >
StorageTagType;
typedef vtkm::cont::internal::Storage< T, StorageTagType > StorageType;
typedef typename ArrayContainerType::ValueType ValueType;
typedef typename ArrayContainerType::PortalType PortalType;
typedef typename StorageType::ValueType ValueType;
typedef typename StorageType::PortalType PortalType;
typedef typename PortalType::IteratorType IteratorType;
void BasicAllocation()
{
ArrayContainerType arrayContainer;
StorageType arrayStorage;
try
{
arrayContainer.GetNumberOfValues();
arrayStorage.GetNumberOfValues();
VTKM_TEST_ASSERT(false == true,
"Implicit Container GetNumberOfValues method didn't throw error.");
"Implicit Storage GetNumberOfValues method didn't throw error.");
}
catch(vtkm::cont::ErrorControlBadValue e) {}
try
{
arrayContainer.Allocate(ARRAY_SIZE);
arrayStorage.Allocate(ARRAY_SIZE);
VTKM_TEST_ASSERT(false == true,
"Implicit Container Allocate method didn't throw error.");
"Implicit Storage Allocate method didn't throw error.");
}
catch(vtkm::cont::ErrorControlBadValue e) {}
try
{
arrayContainer.Shrink(ARRAY_SIZE);
arrayStorage.Shrink(ARRAY_SIZE);
VTKM_TEST_ASSERT(true==false,
"Array shrink do a larger size was possible. This can't be allowed.");
}
@ -113,7 +114,7 @@ struct TemplatedTests
try
{
arrayContainer.ReleaseResources();
arrayStorage.ReleaseResources();
VTKM_TEST_ASSERT(true==false,
"Can't Release an implicit array");
}
@ -122,8 +123,8 @@ struct TemplatedTests
void BasicAccess()
{
TestImplicitContainer<T> portal;
vtkm::cont::ArrayHandle<T,ContainerTagType> implictHandle(portal);
TestImplicitStorage<T> portal;
vtkm::cont::ArrayHandle<T,StorageTagType> implictHandle(portal);
VTKM_TEST_ASSERT(implictHandle.GetNumberOfValues() == 1,
"handle should have size 1");
VTKM_TEST_ASSERT(implictHandle.GetPortalConstControl().Get(0) == T(1),
@ -149,14 +150,14 @@ struct TestFunctor
}
};
void TestArrayContainerControlBasic()
void TestStorageBasic()
{
vtkm::testing::Testing::TryAllTypes(TestFunctor());
}
} // Anonymous namespace
int UnitTestArrayContainerControlImplicit(int, char *[])
int UnitTestStorageImplicit(int, char *[])
{
return vtkm::cont::testing::Testing::Run(TestArrayContainerControlBasic);
return vtkm::cont::testing::Testing::Run(TestStorageBasic);
}

10
vtkm/cont/testing/UnitTestContainerListTag.cxx → vtkm/cont/testing/UnitTestStorageListTag.cxx
View File

@ -18,7 +18,7 @@
// this software.
//============================================================================
#include <vtkm/cont/ContainerListTag.h>
#include <vtkm/cont/StorageListTag.h>
#include <vtkm/cont/testing/Testing.h>
@ -30,7 +30,7 @@ enum TypeId {
BASIC
};
TypeId GetTypeId(vtkm::cont::ArrayContainerControlTagBasic) { return BASIC; }
TypeId GetTypeId(vtkm::cont::StorageTagBasic) { return BASIC; }
struct TestFunctor
{
@ -67,13 +67,13 @@ void TryList(const vtkm::Tuple<TypeId,N> &expected, ListTag)
void TestLists()
{
std::cout << "ContainerListTagBasic" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(BASIC), vtkm::cont::ContainerListTagBasic());
std::cout << "StorageListTagBasic" << std::endl;
TryList(vtkm::Tuple<TypeId,1>(BASIC), vtkm::cont::StorageListTagBasic());
}
} // anonymous namespace
int UnitTestContainerListTag(int, char *[])
int UnitTestStorageListTag(int, char *[])
{
return vtkm::cont::testing::Testing::Run(TestLists);
}