Commit 8280fac1 authored by Robert Maynard's avatar Robert Maynard

Merge branch 'more_fancy_array_portals'

parents ce124b91 c2f2c166
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
// Copyright 2014. Los Alamos National Security
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_cont_ArrayHandleZip_h
#define vtk_m_cont_ArrayHandleZip_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/Pair.h>
namespace vtkm {
namespace exec {
namespace internal {
/// \brief An array portal that zips two portals together into a single value
/// for the execution environment
template<typename ValueType_,
typename PortalTypeFirst,
typename PortalTypeSecond>
class ArrayPortalExecZip
{
public:
typedef ValueType_ ValueType;
typedef ValueType_ IteratorType;
VTKM_CONT_EXPORT
ArrayPortalExecZip(const PortalTypeFirst &portalfirst = PortalTypeFirst(),
const PortalTypeSecond &portalsecond = PortalTypeSecond())
: PortalFirst(portalfirst), PortalSecond(portalsecond)
{ }
/// Copy constructor for any other ArrayPortalExecZip with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherF, class OtherS>
VTKM_CONT_EXPORT
ArrayPortalExecZip(const ArrayPortalExecZip<OtherV,OtherF,OtherS> &src)
: PortalFirst(src.GetFirstPortal()),
PortalSecond(src.GetSecondPortal())
{ }
VTKM_EXEC_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return this->PortalFirst.GetNumberOfValues(); }
VTKM_EXEC_EXPORT
ValueType Get(vtkm::Id index) const {
return vtkm::make_Pair(this->PortalFirst.Get(index),
this->PortalSecond.Get(index));
}
VTKM_EXEC_EXPORT
void Set(vtkm::Id index, const ValueType &value) const {
this->PortalFirst.Set(index, value.first);
this->PortalSecond.Set(index, value.second);
}
VTKM_EXEC_CONT_EXPORT
const PortalTypeFirst &GetFirstPortal() const { return this->PortalFirst; }
VTKM_EXEC_CONT_EXPORT
const PortalTypeSecond &GetSecondPortal() const { return this->PortalSecond; }
private:
PortalTypeFirst PortalFirst;
PortalTypeSecond PortalSecond;
};
}
}
} // namespace vtkm::exec::internal
namespace vtkm {
namespace cont {
namespace internal {
/// \brief An array portal that zips two portals together into a single value
/// for the control environment
template<typename ValueType_,
typename PortalTypeFirst,
typename PortalTypeSecond>
class ArrayPortalContZip
{
public:
typedef ValueType_ ValueType;
typedef ValueType_ IteratorType;
VTKM_CONT_EXPORT
ArrayPortalContZip(const PortalTypeFirst &portalfirst = PortalTypeFirst(),
const PortalTypeSecond &portalsecond = PortalTypeSecond())
: PortalFirst(portalfirst), PortalSecond(portalsecond)
{ }
/// Copy constructor for any other ArrayPortalContZip with an iterator
/// type that can be copied to this iterator type. This allows us to do any
/// type casting that the iterators do (like the non-const to const cast).
///
template<class OtherV, class OtherF, class OtherS>
VTKM_CONT_EXPORT
ArrayPortalContZip(const ArrayPortalContZip<OtherV,OtherF,OtherS> &src)
: PortalFirst(src.GetFirstPortal()),
PortalSecond(src.GetSecondPortal())
{ }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const { return this->PortalFirst.GetNumberOfValues(); }
VTKM_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return vtkm::make_Pair(this->PortalFirst.Get(index),
this->PortalSecond.Get(index));
}
VTKM_CONT_EXPORT
void Set(vtkm::Id index, const ValueType &value) const {
this->PortalFirst.Set(index, value.first);
this->PortalSecond.Set(index, value.second);
}
VTKM_CONT_EXPORT
const PortalTypeFirst &GetFirstPortal() const { return this->PortalFirst; }
VTKM_CONT_EXPORT
const PortalTypeSecond &GetSecondPortal() const { return this->PortalSecond; }
private:
PortalTypeFirst PortalFirst;
PortalTypeSecond PortalSecond;
};
template<typename FirstHandleType, typename SecondHandleType>
struct StorageTagZip;
/// This helper struct defines the value type for a zip container containing
/// the given two array handles.
///
template<typename FirstHandleType, typename SecondHandleType>
struct ArrayHandleZipTraits {
/// The ValueType (a pair containing the value types of the two arrays).
///
typedef vtkm::Pair<typename FirstHandleType::ValueType,
typename SecondHandleType::ValueType> ValueType;
/// The appropriately templated tag.
///
typedef StorageTagZip<FirstHandleType,SecondHandleType> Tag;
};
template<typename T, typename FirstHandleType, typename SecondHandleType>
class Storage<T, StorageTagZip<FirstHandleType, SecondHandleType > >
{
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
public:
typedef T ValueType;
typedef ArrayPortalContZip< ValueType,
typename FirstHandleType::PortalControl,
typename SecondHandleType::PortalControl> PortalType;
typedef ArrayPortalContZip< ValueType,
typename FirstHandleType::PortalConstControl,
typename SecondHandleType::PortalConstControl>
PortalConstType;
VTKM_CONT_EXPORT
Storage() : Valid(false) { }
VTKM_CONT_EXPORT
Storage(const FirstHandleType &farray, const SecondHandleType &sarray)
: FirstArray(farray), SecondArray(sarray), Valid(true)
{
}
VTKM_CONT_EXPORT
PortalType GetPortal() {
VTKM_ASSERT_CONT(this->Valid);
return PortalType(this->FirstArray.GetPortalControl(),
this->SecondArray.GetPortalControl());
}
VTKM_CONT_EXPORT
PortalConstType GetPortalConst() const {
VTKM_ASSERT_CONT(this->Valid);
return PortalConstType(this->FirstArray.GetPortalConstControl(),
this->SecondArray.GetPortalConstControl());
}
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const {
VTKM_ASSERT_CONT(this->Valid);
VTKM_ASSERT_CONT(this->FirstArray.GetNumberOfValues()
== this->SecondArray.GetNumberOfValues());
return this->FirstArray.GetNumberOfValues();
}
VTKM_CONT_EXPORT
void Allocate(vtkm::Id numberOfValues) {
VTKM_ASSERT_CONT(this->Valid);
this->FirstArray.Allocate(numberOfValues);
this->SecondArray.Allocate(numberOfValues);
}
VTKM_CONT_EXPORT
void Shrink(vtkm::Id numberOfValues) {
VTKM_ASSERT_CONT(this->Valid);
this->FirstArray.Shrink(numberOfValues);
this->SecondArray.Shrink(numberOfValues);
}
VTKM_CONT_EXPORT
void ReleaseResources() {
// This request is ignored since it is asking to release the resources
// of the two zipped array, which may be used elsewhere.
}
VTKM_CONT_EXPORT
const FirstHandleType &GetFirstArray() const {
VTKM_ASSERT_CONT(this->Valid);
return this->FirstArray;
}
VTKM_CONT_EXPORT
const SecondHandleType &GetSecondArray() const {
VTKM_ASSERT_CONT(this->Valid);
return this->SecondArray;
}
private:
FirstHandleType FirstArray;
SecondHandleType SecondArray;
bool Valid;
};
template<typename T,
typename FirstHandleType,
typename SecondHandleType,
typename Device>
class ArrayTransfer<
T, StorageTagZip<FirstHandleType,SecondHandleType>, Device>
{
typedef StorageTagZip<FirstHandleType,SecondHandleType> StorageTag;
typedef vtkm::cont::internal::Storage<T, StorageTag> StorageType;
public:
typedef T ValueType;
typedef typename StorageType::PortalType PortalControl;
typedef typename StorageType::PortalConstType PortalConstControl;
typedef vtkm::exec::internal::ArrayPortalExecZip<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::Portal,
typename SecondHandleType::template ExecutionTypes<Device>::Portal
> PortalExecution;
typedef vtkm::exec::internal::ArrayPortalExecZip<
ValueType,
typename FirstHandleType::template ExecutionTypes<Device>::PortalConst,
typename SecondHandleType::template ExecutionTypes<Device>::PortalConst
> PortalConstExecution;
VTKM_CONT_EXPORT
ArrayTransfer(StorageType *storage)
: FirstArray(storage->GetFirstArray()),
SecondArray(storage->GetSecondArray())
{ }
VTKM_CONT_EXPORT
vtkm::Id GetNumberOfValues() const
{
VTKM_ASSERT_CONT( this->FirstArray.GetNumberOfValues()
== this->SecondArray.GetNumberOfValues() );
return this->FirstArray.GetNumberOfValues();
}
VTKM_CONT_EXPORT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) {
return PortalConstExecution(this->FirstArray.PrepareForInput(Device()),
this->SecondArray.PrepareForInput(Device()));
}
VTKM_CONT_EXPORT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData)) {
const vtkm::Id numberOfValues = this->GetNumberOfValues();
return PortalExecution(this->FirstArray.PrepareForOutput(numberOfValues, Device()),
this->SecondArray.PrepareForOutput(numberOfValues, Device()));
}
VTKM_CONT_EXPORT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
{
return PortalExecution( this->FirstArray.PrepareForOutput(numberOfValues, Device()),
this->SecondArray.PrepareForOutput(numberOfValues, Device()) );
}
VTKM_CONT_EXPORT
void RetrieveOutputData(StorageType *vtkmNotUsed(storage)) const {
// Implementation of this method should be unnecessary. The internal
// first and second array handles should automatically retrieve the
// output data as necessary.
}
VTKM_CONT_EXPORT
void Shrink(vtkm::Id numberOfValues) {
this->FirstArray.Shrink(numberOfValues);
this->SecondArray.Shrink(numberOfValues);
}
VTKM_CONT_EXPORT
void ReleaseResources() {
this->FirstArray.ReleaseResourcesExecution();
this->SecondArray.ReleaseResourcesExecution();
}
private:
FirstHandleType FirstArray;
SecondHandleType SecondArray;
};
} // namespace internal
/// ArrayHandleZip is a specialization of ArrayHandle. It takes two delegate
/// array handle and makes a new handle that access the corresponding entries
/// in these arrays as a pair.
///
template<typename FirstHandleType,
typename SecondHandleType>
class ArrayHandleZip
: public vtkm::cont::ArrayHandle<
typename internal::ArrayHandleZipTraits<FirstHandleType,SecondHandleType>::ValueType,
typename internal::ArrayHandleZipTraits<FirstHandleType,SecondHandleType>::Tag
>
{
// If the following line gives a compile error, then the FirstHandleType
// template argument is not a valid ArrayHandle type.
VTKM_IS_ARRAY_HANDLE(FirstHandleType);
// If the following line gives a compile error, then the SecondHandleType
// template argument is not a valid ArrayHandle type.
VTKM_IS_ARRAY_HANDLE(SecondHandleType);
typedef typename internal::ArrayHandleZipTraits<FirstHandleType,
SecondHandleType>::ValueType VType;
typedef typename internal::ArrayHandleZipTraits<FirstHandleType,
SecondHandleType>::Tag StorageTag;
typedef vtkm::cont::internal::Storage<VType, StorageTag> StorageType;
public:
typedef vtkm::cont::ArrayHandle<VType, StorageTag> Superclass;
ArrayHandleZip() : Superclass( ) { }
ArrayHandleZip(const FirstHandleType &firstArray,
const SecondHandleType &secondArray)
: Superclass( StorageType( firstArray, secondArray ) ) { }
};
/// A convenience function for creating an ArrayHandleZip. It takes the two
/// arrays to be zipped together.
///
template<typename FirstHandleType, typename SecondHandleType>
VTKM_CONT_EXPORT
vtkm::cont::ArrayHandleZip<FirstHandleType,SecondHandleType>
make_ArrayHandleZip(const FirstHandleType &first,
const SecondHandleType &second)
{
return ArrayHandleZip<FirstHandleType,SecondHandleType>(first, second);
}
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ArrayHandleZip_h
......@@ -28,6 +28,7 @@ set(headers
ArrayHandlePermutation.h
ArrayHandleTransform.h
ArrayHandleUniformPointCoordinates.h
ArrayHandleZip.h
ArrayPortal.h
ArrayPortalToIterators.h
Assert.h
......
......@@ -20,7 +20,7 @@
set(unit_tests
UnitTestCudaArrayHandle.cu
UnitTestCudaArrayHandleCounting.cu
UnitTestCudaArrayHandleFancy.cu
UnitTestDeviceAdapterCuda.cu
)
vtkm_unit_tests(CUDA SOURCES ${unit_tests})
......@@ -18,84 +18,18 @@
// this software.
//============================================================================
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_CUDA
#define VTKM_DEVICE_ADAPTER VTKM_DEVICE_ADAPTER_ERROR
#define BOOST_SP_DISABLE_THREADS
#include <vtkm/cont/cuda/DeviceAdapterCuda.h>
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/cont/testing/TestingFancyArrayHandles.h>
#include <vtkm/cont/cuda/internal/testing/Testing.h>
namespace ut_handle_counting{
const vtkm::Id ARRAY_SIZE = 300;
struct PassThrough : public vtkm::worklet::WorkletMapField
int UnitTestCudaArrayHandleFancy(int, char *[])
{
typedef void ControlSignature(FieldIn<>, FieldOut<>);
typedef _2 ExecutionSignature(_1);
template<class ValueType>
VTKM_EXEC_EXPORT
ValueType operator()(const ValueType &inValue) const
{ return inValue; }
};
template< typename ValueType >
struct CountingTest
{
void operator()(const ValueType v) const
{
const ValueType start = v;
const ValueType end = start + ARRAY_SIZE;
vtkm::cont::ArrayHandleCounting< ValueType > implicit =
vtkm::cont::make_ArrayHandleCounting(start, end);
vtkm::cont::ArrayHandle< ValueType > result;
vtkm::worklet::DispatcherMapField< ut_handle_counting::PassThrough > dispatcher;
dispatcher.Invoke(implicit, result);
//verify that the control portal works
for(int i=v; i < ARRAY_SIZE; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType correct_value = v + ValueType(i);
VTKM_TEST_ASSERT(result_v == correct_value, "Counting Handle Failed");
}
}
};
template <typename T>
void RunCountingTest(const T t)
{
CountingTest<T> tests;
tests(t);
}
void TestArrayHandleCounting()
{
RunCountingTest( vtkm::Id(42) );
RunCountingTest( vtkm::Float32(3) );
// RunCountingTest( vtkm::Vec< vtkm::Float32, 3>() );
int result = vtkm::cont::testing::TestingFancyArrayHandles
<vtkm::cont::DeviceAdapterTagCuda>::Run();
return vtkm::cont::cuda::internal::Testing::CheckCudaBeforeExit(result);
}
} // ut_handle_counting namespace
int UnitTestCudaArrayHandleCounting(int, char *[])
{
return vtkm::cont::cuda::internal::Testing::Run(
ut_handle_counting::TestArrayHandleCounting);
}
......@@ -21,6 +21,7 @@
set(headers
Testing.h
TestingDeviceAdapter.h
TestingFancyArrayHandles.h
)
vtkm_declare_headers(${headers})
......@@ -29,6 +30,7 @@ set(unit_tests
UnitTestArrayHandle.cxx
UnitTestArrayHandleCompositeVector.cxx
UnitTestArrayHandleCounting.cxx
UnitTestArrayHandleFancy.cxx
UnitTestArrayHandleImplicit.cxx
UnitTestArrayHandlePermutation.cxx
UnitTestArrayHandleTransform.cxx
......
//=============================================================================
//
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2015 Sandia Corporation.
// Copyright 2015 UT-Battelle, LLC.
// Copyright 2015. Los Alamos National Security
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//
//=============================================================================
#ifndef vtk_m_cont_testing_TestingFancyArrayHandles_h
#define vtk_m_cont_testing_TestingFancyArrayHandles_h
#include <vtkm/cont/ArrayHandleCounting.h>
#include <vtkm/cont/ArrayHandleImplicit.h>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/ArrayHandleTransform.h>
#include <vtkm/cont/ArrayHandleZip.h>
#include <vtkm/VecTraits.h>
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/cont/testing/Testing.h>
namespace fancy_array_detail
{
template<typename T>
class IncrementBy2
{
public:
VTKM_EXEC_CONT_EXPORT
IncrementBy2(): Value(0)
{
}
VTKM_EXEC_CONT_EXPORT
explicit IncrementBy2(vtkm::Id index):
Value(0) //required before we increment
{
VTKM_ASSERT_CONT(index >= 0);
for (vtkm::Id i = 0; i < index; i++)
{ this->Value++; this->Value++; }
}
VTKM_EXEC_CONT_EXPORT
IncrementBy2 operator+(const IncrementBy2 &rhs) const
{
//don't want to trigger the vtkm::Id constructor
//when making a copy and cause this to be IncrementBy4
IncrementBy2 newValue;
newValue.Value = this->Value + rhs.Value;
return newValue;
}
VTKM_EXEC_CONT_EXPORT
bool operator==(const IncrementBy2 &other) const
{
return this->Value == other.Value;
}
VTKM_EXEC_CONT_EXPORT
IncrementBy2 &operator++()
{
this->Value++;
this->Value++;
return *this;
}
VTKM_CONT_EXPORT
friend std::ostream& operator<<(std::ostream &os, const IncrementBy2 &v)
{ os << v.Value; return os; }
T Value;
};
template<typename ValueType>
struct IndexSquared
{
VTKM_EXEC_CONT_EXPORT