Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-05 01:49:02 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Use new ways to get array portal in control environment

Browse Source 
Also fix deadlocks that occur when portals are not destroyed
in time.
This commit is contained in:
Kenneth Moreland 2020-01-28 12:14:32 -07:00
parent 8ddde979f0
commit ec34cb56c4
284 changed files with 1750 additions and 1876 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
benchmarking/BenchmarkArrayTransfer.cxx
View File

@ -238,7 +238,7 @@ void BenchRoundTripRead(benchmark::State& state)
invoker(ReadValues{}, array);
// Copy back to host and read:
auto portal = array.GetPortalConstControl();
auto portal = array.ReadPortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
benchmark::DoNotOptimize(portal.Get(i));
@ -292,7 +292,7 @@ void BenchRoundTripReadWrite(benchmark::State& state)
// Do work on device:
invoker(ReadWriteValues{}, array);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
portal.Set(i, portal.Get(i) - static_cast<ValueType>(i));
@ -345,7 +345,7 @@ void BenchExecToContRead(benchmark::State& state)
invoker(WriteValues{}, array);
// Read back on host:
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
benchmark::DoNotOptimize(portal.Get(i));
@ -397,7 +397,7 @@ void BenchExecToContWrite(benchmark::State& state)
invoker(WriteValues{}, array);
// Read back on host:
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
portal.Set(i, portal.Get(i) - static_cast<ValueType>(i));
@ -449,7 +449,7 @@ void BenchExecToContReadWrite(benchmark::State& state)
invoker(WriteValues{}, array);
// Read back on host:
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
benchmark::DoNotOptimize(portal.Get(i));

4
benchmarking/BenchmarkDeviceAdapter.cxx
View File

@ -173,7 +173,7 @@ VTKM_CONT void FillRandomTestValue(ArrayT& array, vtkm::Id numValues)
std::mt19937_64 rng;
array.Allocate(numValues);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < portal.GetNumberOfValues(); ++i)
{
portal.Set(i, TestValue(static_cast<vtkm::Id>(rng()), ValueType{}));
@ -188,7 +188,7 @@ VTKM_CONT void FillRandomModTestValue(ArrayT& array, vtkm::Id mod, vtkm::Id numV
std::mt19937_64 rng;
array.Allocate(numValues);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < portal.GetNumberOfValues(); ++i)
{
portal.Set(i, TestValue(static_cast<vtkm::Id>(rng()) % mod, ValueType{}));

16
benchmarking/BenchmarkFieldAlgorithms.cxx
View File

@ -375,9 +375,9 @@ struct BenchBlackScholesImpl
this->OptionStrike.Allocate(this->ArraySize);
this->OptionYears.Allocate(this->ArraySize);
auto stockPricePortal = this->StockPrice.GetPortalControl();
auto optionStrikePortal = this->OptionStrike.GetPortalControl();
auto optionYearsPortal = this->OptionYears.GetPortalControl();
auto stockPricePortal = this->StockPrice.WritePortal();
auto optionStrikePortal = this->OptionStrike.WritePortal();
auto optionYearsPortal = this->OptionYears.WritePortal();
for (vtkm::Id i = 0; i < this->ArraySize; ++i)
{
@ -488,7 +488,7 @@ struct BenchMathImpl
std::uniform_real_distribution<Value> range;
this->InputHandle.Allocate(this->ArraySize);
auto portal = this->InputHandle.GetPortalControl();
auto portal = this->InputHandle.WritePortal();
for (vtkm::Id i = 0; i < this->ArraySize; ++i)
{
portal.Set(i, vtkm::Vec<Value, 3>{ range(rng), range(rng), range(rng) });
@ -590,7 +590,7 @@ struct BenchFusedMathImpl
std::uniform_real_distribution<Value> range;
this->InputHandle.Allocate(this->ArraySize);
auto portal = this->InputHandle.GetPortalControl();
auto portal = this->InputHandle.WritePortal();
for (vtkm::Id i = 0; i < this->ArraySize; ++i)
{
portal.Set(i, vtkm::Vec<Value, 3>{ range(rng), range(rng), range(rng) });
@ -702,7 +702,7 @@ struct BenchEdgeInterpImpl
{ // Per-edge weights
this->WeightHandle.Allocate(numberOfEdges);
auto portal = this->WeightHandle.GetPortalControl();
auto portal = this->WeightHandle.WritePortal();
for (vtkm::Id i = 0; i < numberOfEdges; ++i)
{
portal.Set(i, weight_range(rng));
@ -711,7 +711,7 @@ struct BenchEdgeInterpImpl
{ // Point field
this->FieldHandle.Allocate(cellSet.GetNumberOfPoints());
auto portal = this->FieldHandle.GetPortalControl();
auto portal = this->FieldHandle.WritePortal();
for (vtkm::Id i = 0; i < portal.GetNumberOfValues(); ++i)
{
portal.Set(i, field_range(rng));
@ -788,7 +788,7 @@ static ImplicitFunctionBenchData MakeImplicitFunctionBenchData()
std::uniform_real_distribution<vtkm::FloatDefault> disty(bounds[2], bounds[3]);
std::uniform_real_distribution<vtkm::FloatDefault> distz(bounds[4], bounds[5]);
auto portal = data.Points.GetPortalControl();
auto portal = data.Points.WritePortal();
for (vtkm::Id i = 0; i < count; ++i)
{
portal.Set(i, vtkm::make_Vec(distx(rangen), disty(rangen), distz(rangen)));

6
benchmarking/BenchmarkRayTracing.cxx
View File

@ -71,7 +71,7 @@ void BenchRayTracing(::benchmark::State& state)
rays.Buffers.at(0).InitConst(0.f);
vtkm::cont::Field field = dataset.GetField("pointvar");
vtkm::Range range = field.GetRange().GetPortalConstControl().Get(0);
vtkm::Range range = field.GetRange().ReadPortal().Get(0);
tracer.SetField(field, range);
@ -81,8 +81,8 @@ void BenchRayTracing(::benchmark::State& state)
vtkm::cont::ArrayHandle<vtkm::Vec4f_32> colors;
colors.Allocate(100);
auto portal = colors.GetPortalControl();
auto colorPortal = temp.GetPortalConstControl();
auto portal = colors.WritePortal();
auto colorPortal = temp.ReadPortal();
constexpr vtkm::Float32 conversionToFloatSpace = (1.0f / 255.0f);
for (vtkm::Id i = 0; i < 100; ++i)
{

2
benchmarking/BenchmarkTopologyAlgorithms.cxx
View File

@ -160,7 +160,7 @@ VTKM_CONT typename ArrayT::ValueType FillRandomValues(ArrayT& array,
NumberGenerator<ValueType> generator{ static_cast<ValueType>(min), static_cast<ValueType>(max) };
array.Allocate(size);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::Id i = 0; i < size; ++i)
{
portal.Set(i, generator.next());

6
examples/contour_tree_augmented/ContourTreeApp.cxx
View File

@ -558,9 +558,9 @@ int main(int argc, char* argv[])
localBlockIndices.Allocate(blocksPerRank);
localBlockOrigins.Allocate(blocksPerRank);
localBlockSizes.Allocate(blocksPerRank);
auto localBlockIndicesPortal = localBlockIndices.GetPortalControl();
auto localBlockOriginsPortal = localBlockOrigins.GetPortalControl();
auto localBlockSizesPortal = localBlockSizes.GetPortalControl();
auto localBlockIndicesPortal = localBlockIndices.WritePortal();
auto localBlockOriginsPortal = localBlockOrigins.WritePortal();
auto localBlockSizesPortal = localBlockSizes.WritePortal();
{
vtkm::Id lastDimSize =

6
examples/histogram/Histogram.cxx
View File

@ -43,8 +43,8 @@ VTKM_CONT vtkm::cont::ArrayHandle<T> CreateArray(T min, T max, vtkm::Id numVals)
vtkm::cont::ArrayHandle<T> handle;
handle.Allocate(numVals);
std::generate(vtkm::cont::ArrayPortalToIteratorBegin(handle.GetPortalControl()),
vtkm::cont::ArrayPortalToIteratorEnd(handle.GetPortalControl()),
std::generate(vtkm::cont::ArrayPortalToIteratorBegin(handle.WritePortal()),
vtkm::cont::ArrayPortalToIteratorEnd(handle.WritePortal()),
[&]() { return static_cast<T>(dis(gen)); });
return handle;
}
@ -92,7 +92,7 @@ int main(int argc, char* argv[])
vtkm::cont::ArrayHandle<vtkm::Id> bins;
result.GetPartition(0).GetField("histogram").GetData().CopyTo(bins);
auto binPortal = bins.GetPortalConstControl();
auto binPortal = bins.ReadPortal();
if (rank == 0)
{
// print histogram.

12
examples/histogram/HistogramMPI.hxx
View File

@ -58,8 +58,8 @@ public:
// reduce local bins first.
vtkm::cont::ArrayHandle<vtkm::Id> local;
local.Allocate(numBins);
std::fill(vtkm::cont::ArrayPortalToIteratorBegin(local.GetPortalControl()),
vtkm::cont::ArrayPortalToIteratorEnd(local.GetPortalControl()),
std::fill(vtkm::cont::ArrayPortalToIteratorBegin(local.WritePortal()),
vtkm::cont::ArrayPortalToIteratorEnd(local.WritePortal()),
static_cast<vtkm::Id>(0));
for (const auto& lbins : this->LocalBlocks)
{
@ -70,8 +70,8 @@ public:
// converting to std::vector
std::vector<vtkm::Id> send_buf(static_cast<std::size_t>(numBins));
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(local.GetPortalConstControl()),
vtkm::cont::ArrayPortalToIteratorEnd(local.GetPortalConstControl()),
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(local.ReadPortal()),
vtkm::cont::ArrayPortalToIteratorEnd(local.ReadPortal()),
send_buf.begin());
std::vector<vtkm::Id> recv_buf(static_cast<std::size_t>(numBins));
@ -88,7 +88,7 @@ public:
local.Allocate(numBins);
std::copy(recv_buf.begin(),
recv_buf.end(),
vtkm::cont::ArrayPortalToIteratorBegin(local.GetPortalControl()));
vtkm::cont::ArrayPortalToIteratorBegin(local.WritePortal()));
return local;
}
return vtkm::cont::ArrayHandle<vtkm::Id>();
@ -158,7 +158,7 @@ inline VTKM_CONT void HistogramMPI::PreExecute(const vtkm::cont::PartitionedData
{
throw vtkm::cont::ErrorFilterExecution("expecting scalar field.");
}
this->ComputedRange = handle.GetPortalConstControl().Get(0);
this->ComputedRange = handle.ReadPortal().Get(0);
}
}

2
examples/lagrangian/lagrangian.cxx
View File

@ -65,7 +65,7 @@ vtkm::cont::DataSet make3DRectilinearDataSet(double time)
double vec[3];
double loc[3] = { i * xdiff + xmin, j * ydiff + ymax, k * zdiff + zmin };
field.calculateVelocity(loc, time, vec);
velocityField.GetPortalControl().Set(count, vtkm::Vec3f_64(vec[0], vec[1], vec[2]));
velocityField.WritePortal().Set(count, vtkm::Vec3f_64(vec[0], vec[1], vec[2]));
count++;
}
}

4
examples/temporal_advection/TemporalAdvection.cxx
View File

@ -76,8 +76,8 @@ int main(int argc, char** argv)
vtkm::Id numPts = pts.GetNumberOfValues();
seeds.Allocate(numPts);
auto ptsPortal = pts.GetPortalConstControl();
auto seedPortal = seeds.GetPortalConstControl();
auto ptsPortal = pts.ReadPortal();
auto seedPortal = seeds.ReadPortal();
for (vtkm::Id i = 0; i < numPts; i++)
{
vtkm::Particle p;

10
vtkm/cont/ArrayGetValues.h
View File

@ -35,8 +35,8 @@ namespace cont
///
/// These functions should not be called repeatedly in a loop to fetch all
/// values from an array handle. The much more efficient way to do this is to
/// use the proper control-side portals (ArrayHandle::GetPortalControl() and
/// ArrayHandle::GetPortalConstControl()).
/// use the proper control-side portals (ArrayHandle::WritePortal() and
/// ArrayHandle::ReadPortal()).
///
/// This method will attempt to copy the data using the device that the input
/// data is already valid on. If the input data is only valid in the control
@ -111,10 +111,10 @@ VTKM_CONT void ArrayGetValues(const vtkm::cont::ArrayHandle<vtkm::Id, SIds>& ids
{ // Fallback to a control-side copy if the device copy fails or if the device
// is undefined:
const vtkm::Id numVals = ids.GetNumberOfValues();
auto idPortal = ids.GetPortalConstControl();
auto dataPortal = data.GetPortalConstControl();
auto idPortal = ids.ReadPortal();
auto dataPortal = data.ReadPortal();
output.Allocate(numVals);
auto outPortal = output.GetPortalControl();
auto outPortal = output.WritePortal();
for (vtkm::Id i = 0; i < numVals; ++i)
{
outPortal.Set(i, dataPortal.Get(idPortal.Get(i)));

9
vtkm/cont/ArrayHandle.h
View File

@ -82,7 +82,7 @@ using IsInValidArrayHandle =
///
template <typename ArrayHandle>
using IsWritableArrayHandle =
vtkm::internal::PortalSupportsSets<typename std::decay<ArrayHandle>::type::PortalControl>;
vtkm::internal::PortalSupportsSets<typename std::decay<ArrayHandle>::type::WritePortalType>;
/// @}
/// Checks to see if the given object is an array handle. This check is
@ -804,8 +804,7 @@ make_ArrayHandle(const T* array, vtkm::Id length, vtkm::CopyFlag copy = vtkm::Co
{
ArrayHandleType handle;
handle.Allocate(length);
std::copy(
array, array + length, vtkm::cont::ArrayPortalToIteratorBegin(handle.GetPortalControl()));
std::copy(array, array + length, vtkm::cont::ArrayPortalToIteratorBegin(handle.WritePortal()));
return handle;
}
else
@ -907,7 +906,7 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle(
bool full = false)
{
using ArrayType = vtkm::cont::ArrayHandle<T, StorageT>;
using PortalType = typename ArrayType::PortalConstControl;
using PortalType = typename ArrayType::ReadPortalType;
using IsVec = typename vtkm::VecTraits<T>::HasMultipleComponents;
vtkm::Id sz = array.GetNumberOfValues();
@ -915,7 +914,7 @@ VTKM_NEVER_EXPORT VTKM_CONT inline void printSummary_ArrayHandle(
out << "valueType=" << typeid(T).name() << " storageType=" << typeid(StorageT).name()
<< " numValues=" << sz << " bytes=" << (static_cast<size_t>(sz) * sizeof(T)) << " [";
PortalType portal = array.GetPortalConstControl();
PortalType portal = array.ReadPortal();
if (full || sz <= 7)
{
for (vtkm::Id i = 0; i < sz; i++)

4
vtkm/cont/ArrayHandle.hxx
View File

@ -451,7 +451,7 @@ inline void VTKM_CONT StorageSerialization(vtkmdiy::BinaryBuffer& bb,
vtkmdiy::save(bb, count);
vtkmdiy::save(bb, vtkm::Id(0)); //not a basic storage
auto portal = obj.GetPortalConstControl();
auto portal = obj.ReadPortal();
for (vtkm::Id i = 0; i < count; ++i)
{
vtkmdiy::save(bb, portal.Get(i));
@ -501,7 +501,7 @@ VTKM_CONT void Serialization<vtkm::cont::ArrayHandle<T>>::load(BinaryBuffer& bb,
}
else
{
auto portal = obj.GetPortalControl();
auto portal = obj.WritePortal();
for (vtkm::Id i = 0; i < count; ++i)
{
T val{};

4
vtkm/cont/ArrayHandleBitField.h
View File

@ -88,10 +88,10 @@ public:
VTKM_CONT Storage& operator=(Storage&&) noexcept = default;
VTKM_CONT
PortalType GetPortal() { return PortalType{ this->Data.GetPortalControl() }; }
PortalType GetPortal() { return PortalType{ this->Data.WritePortal() }; }
VTKM_CONT
PortalConstType GetPortalConst() { return PortalConstType{ this->Data.GetPortalConstControl() }; }
PortalConstType GetPortalConst() { return PortalConstType{ this->Data.ReadPortal() }; }
VTKM_CONT vtkm::Id GetNumberOfValues() const { return this->Data.GetNumberOfBits(); }
VTKM_CONT void Allocate(vtkm::Id numberOfValues) { this->Data.Allocate(numberOfValues); }

26
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -208,15 +208,16 @@ class Storage<vtkm::Vec<T, 3>, vtkm::cont::StorageTagCartesianProduct<ST1, ST2,
public:
using ValueType = vtkm::Vec<typename AH1::ValueType, 3>;
using PortalType = vtkm::exec::internal::ArrayPortalCartesianProduct<ValueType,
typename AH1::PortalControl,
typename AH2::PortalControl,
typename AH3::PortalControl>;
using PortalType =
vtkm::exec::internal::ArrayPortalCartesianProduct<ValueType,
typename AH1::WritePortalType,
typename AH2::WritePortalType,
typename AH3::WritePortalType>;
using PortalConstType =
vtkm::exec::internal::ArrayPortalCartesianProduct<ValueType,
typename AH1::PortalConstControl,
typename AH2::PortalConstControl,
typename AH3::PortalConstControl>;
typename AH1::ReadPortalType,
typename AH2::ReadPortalType,
typename AH3::ReadPortalType>;
VTKM_CONT
Storage()
@ -237,17 +238,16 @@ public:
VTKM_CONT
PortalType GetPortal()
{
return PortalType(this->FirstArray.GetPortalControl(),
this->SecondArray.GetPortalControl(),
this->ThirdArray.GetPortalControl());
return PortalType(this->FirstArray.WritePortal(),
this->SecondArray.WritePortal(),
this->ThirdArray.WritePortal());
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
return PortalConstType(this->FirstArray.GetPortalConstControl(),
this->SecondArray.GetPortalConstControl(),
this->ThirdArray.GetPortalConstControl());
return PortalConstType(
this->FirstArray.ReadPortal(), this->SecondArray.ReadPortal(), this->ThirdArray.ReadPortal());
}
VTKM_CONT

12
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -120,14 +120,14 @@ struct ArrayTupleForEach
template <typename PortalTuple>
VTKM_CONT static void GetPortalTupleControl(ArrayTuple& arrays, PortalTuple& portals)
{
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).GetPortalControl();
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).WritePortal();
Next::GetPortalTupleControl(arrays, portals);
}
template <typename PortalTuple>
VTKM_CONT static void GetPortalConstTupleControl(const ArrayTuple& arrays, PortalTuple& portals)
{
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).GetPortalConstControl();
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).ReadPortal();
Next::GetPortalConstTupleControl(arrays, portals);
}
@ -228,10 +228,10 @@ template <typename Head, typename... Tail>
struct PortalTupleTypeGeneratorImpl<vtkmstd::tuple<Head, Tail...>>
{
using Next = PortalTupleTypeGeneratorImpl<vtkmstd::tuple<Tail...>>;
using PortalControlTuple = typename TupleTypePrepend<typename Head::PortalControl,
using PortalControlTuple = typename TupleTypePrepend<typename Head::WritePortalType,
typename Next::PortalControlTuple>::Type;
using PortalConstControlTuple =
typename TupleTypePrepend<typename Head::PortalConstControl,
typename TupleTypePrepend<typename Head::ReadPortalType,
typename Next::PortalConstControlTuple>::Type;
template <typename DeviceTag>
@ -249,8 +249,8 @@ struct PortalTupleTypeGeneratorImpl<vtkmstd::tuple<Head, Tail...>>
template <typename Head>
struct PortalTupleTypeGeneratorImpl<vtkmstd::tuple<Head>>
{
using PortalControlTuple = vtkmstd::tuple<typename Head::PortalControl>;
using PortalConstControlTuple = vtkmstd::tuple<typename Head::PortalConstControl>;
using PortalControlTuple = vtkmstd::tuple<typename Head::WritePortalType>;
using PortalConstControlTuple = vtkmstd::tuple<typename Head::ReadPortalType>;
template <typename DeviceTag>
struct ExecutionTypes

13
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -155,10 +155,10 @@ class Storage<T, StorageTagConcatenate<ST1, ST2>>
public:
using ValueType = T;
using PortalType = ArrayPortalConcatenate<typename ArrayHandleType1::PortalControl,
typename ArrayHandleType2::PortalControl>;
using PortalConstType = ArrayPortalConcatenate<typename ArrayHandleType1::PortalConstControl,
typename ArrayHandleType2::PortalConstControl>;
using PortalType = ArrayPortalConcatenate<typename ArrayHandleType1::WritePortalType,
typename ArrayHandleType2::WritePortalType>;
using PortalConstType = ArrayPortalConcatenate<typename ArrayHandleType1::ReadPortalType,
typename ArrayHandleType2::ReadPortalType>;
VTKM_CONT
Storage()
@ -178,15 +178,14 @@ public:
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->valid);
return PortalConstType(this->array1.GetPortalConstControl(),
this->array2.GetPortalConstControl());
return PortalConstType(this->array1.ReadPortal(), this->array2.ReadPortal());
}
VTKM_CONT
PortalType GetPortal()
{
VTKM_ASSERT(this->valid);
return PortalType(this->array1.GetPortalControl(), this->array2.GetPortalControl());
return PortalType(this->array1.WritePortal(), this->array2.WritePortal());
}
VTKM_CONT

6
vtkm/cont/ArrayHandleConstant.h
View File

@ -79,8 +79,8 @@ public:
VTKM_CONT
ArrayHandleConstant(T value, vtkm::Id numberOfValues = 0)
: Superclass(typename Superclass::PortalConstControl(internal::ConstantFunctor<T>(value),
numberOfValues))
: Superclass(
typename Superclass::ReadPortalType(internal::ConstantFunctor<T>(value), numberOfValues))
{
}
};
@ -137,7 +137,7 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
vtkmdiy::save(bb, obj.GetNumberOfValues());
vtkmdiy::save(bb, obj.GetPortalConstControl().Get(0));
vtkmdiy::save(bb, obj.ReadPortal().Get(0));
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)

4
vtkm/cont/ArrayHandleCounting.h
View File

@ -126,7 +126,7 @@ public:
VTKM_CONT
ArrayHandleCounting(CountingValueType start, CountingValueType step, vtkm::Id length)
: Superclass(typename Superclass::PortalConstControl(start, step, length))
: Superclass(typename Superclass::ReadPortalType(start, step, length))
{
}
};
@ -181,7 +181,7 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
auto portal = obj.ReadPortal();
vtkmdiy::save(bb, portal.GetStart());
vtkmdiy::save(bb, portal.GetStep());
vtkmdiy::save(bb, portal.GetNumberOfValues());

34
vtkm/cont/ArrayHandleDecorator.h
View File

@ -211,17 +211,17 @@ struct GetInverseFunctorTypeImpl<std::false_type, DecoratorImplT, PortalList>
// See note below about using non-writable portals in invertible functors.
// We need to sub in const portals when writable ones don't exist.
template <typename ArrayT>
typename std::decay<ArrayT>::type::PortalControl GetPortalControlImpl(std::true_type,
typename std::decay<ArrayT>::type::WritePortalType GetPortalControlImpl(std::true_type,
ArrayT&& array)
{
return array.GetPortalControl();
return array.WritePortal();
}
template <typename ArrayT>
typename std::decay<ArrayT>::type::PortalConstControl GetPortalControlImpl(std::false_type,
typename std::decay<ArrayT>::type::ReadPortalType GetPortalControlImpl(std::false_type,
ArrayT&& array)
{
return array.GetPortalConstControl();
return array.ReadPortal();
}
template <typename ArrayT, typename Device>
@ -265,13 +265,13 @@ GetPortalOutputImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token&
// const array handles so we can at least read from them in the inverse
// functors.
template <typename ArrayT,
typename Portal = typename std::decay<ArrayT>::type::PortalControl,
typename PortalConst = typename std::decay<ArrayT>::type::PortalConstControl>
typename Portal = typename std::decay<ArrayT>::type::WritePortalType,
typename PortalConst = typename std::decay<ArrayT>::type::ReadPortalType>
using GetPortalControlType =
typename brigand::if_<vtkm::internal::PortalSupportsSets<Portal>, Portal, PortalConst>::type;
template <typename ArrayT>
using GetPortalConstControlType = typename std::decay<ArrayT>::type::PortalConstControl;
using GetPortalConstControlType = typename std::decay<ArrayT>::type::ReadPortalType;
template <typename ArrayT,
typename Device,
@ -289,16 +289,15 @@ using GetPortalConstExecutionType =
// Get portal objects:
// See note above -- we swap in const portals sometimes.
template <typename ArrayT>
GetPortalControlType<typename std::decay<ArrayT>::type> GetPortalControl(ArrayT&& array)
GetPortalControlType<typename std::decay<ArrayT>::type> WritePortal(ArrayT&& array)
{
return detail::GetPortalControlImpl(IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array));
}
template <typename ArrayT>
GetPortalConstControlType<typename std::decay<ArrayT>::type> GetPortalConstControl(
const ArrayT& array)
GetPortalConstControlType<typename std::decay<ArrayT>::type> ReadPortal(const ArrayT& array)
{
return array.GetPortalConstControl();
return array.ReadPortal();
}
template <typename ArrayT, typename Device>
@ -377,15 +376,14 @@ using GetInverseFunctorType =
// - So we jump through some decltype/declval hoops here to get this to work:
template <typename... ArrayTs>
using GetPortalConstControlList =
brigand::list<decltype((GetPortalConstControl(std::declval<ArrayTs&>())))...>;
brigand::list<decltype((ReadPortal(std::declval<ArrayTs&>())))...>;
template <typename Device, typename... ArrayTs>
using GetPortalConstExecutionList = brigand::list<decltype(
(GetPortalInput(std::declval<ArrayTs&>(), Device{}, std::declval<vtkm::cont::Token&>())))...>;
template <typename... ArrayTs>
using GetPortalControlList =
brigand::list<decltype((GetPortalControl(std::declval<ArrayTs&>())))...>;
using GetPortalControlList = brigand::list<decltype((WritePortal(std::declval<ArrayTs&>())))...>;
template <typename Device, typename... ArrayTs>
using GetPortalExecutionList = brigand::list<decltype(
@ -553,7 +551,7 @@ struct DecoratorStorageTraits
// Indices{}.value : Works on both MSVC2015 and MSVC2017.
//
// Don't touch the following line unless you really, really have to.
GetPortalControl(vtkmstd::get<Indices{}.value>(arrays))...);
WritePortal(vtkmstd::get<Indices{}.value>(arrays))...);
}
template <template <typename...> class List, typename... Indices>
@ -567,7 +565,7 @@ struct DecoratorStorageTraits
impl,
// Don't touch the following line unless you really, really have to. See
// note in MakePortalControl.
GetPortalConstControl(vtkmstd::get<Indices{}.value>(arrays))...);
ReadPortal(vtkmstd::get<Indices{}.value>(arrays))...);
}
template <template <typename...> class List, typename... Indices, typename Device>
@ -646,7 +644,7 @@ struct DecoratorStorageTraits
List<std::size_t, Indices...>)
{
return CreatePortalDecorator<PortalControlType>(
numValues, impl, GetPortalControl(vtkmstd::get<Indices>(arrays))...);
numValues, impl, WritePortal(vtkmstd::get<Indices>(arrays))...);
}
template <template <typename, std::size_t...> class List, std::size_t... Indices>
@ -656,7 +654,7 @@ struct DecoratorStorageTraits
List<std::size_t, Indices...>)
{
return CreatePortalDecorator<PortalConstControlType>(
numValues, impl, GetPortalConstControl(vtkmstd::get<Indices>(arrays))...);
numValues, impl, ReadPortal(vtkmstd::get<Indices>(arrays))...);
}
template <template <typename, std::size_t...> class List, std::size_t... Indices, typename Device>

8
vtkm/cont/ArrayHandleExtractComponent.h
View File

@ -95,8 +95,8 @@ class Storage<typename vtkm::VecTraits<typename ArrayHandleType::ValueType>::Com
StorageTagExtractComponent<ArrayHandleType>>
{
public:
using PortalType = ArrayPortalExtractComponent<typename ArrayHandleType::PortalControl>;
using PortalConstType = ArrayPortalExtractComponent<typename ArrayHandleType::PortalConstControl>;
using PortalType = ArrayPortalExtractComponent<typename ArrayHandleType::WritePortalType>;
using PortalConstType = ArrayPortalExtractComponent<typename ArrayHandleType::ReadPortalType>;
using ValueType = typename PortalType::ValueType;
VTKM_CONT
@ -119,14 +119,14 @@ public:
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(this->Array.GetPortalConstControl(), this->Component);
return PortalConstType(this->Array.ReadPortal(), this->Component);
}
VTKM_CONT
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->Array.GetPortalControl(), this->Component);
return PortalType(this->Array.WritePortal(), this->Component);
}
VTKM_CONT

8
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -127,10 +127,10 @@ public:
using ValueType = vtkm::Vec<ComponentType, NUM_COMPONENTS>;
using PortalType =
vtkm::exec::internal::ArrayPortalGroupVec<typename SourceArrayHandleType::PortalControl,
vtkm::exec::internal::ArrayPortalGroupVec<typename SourceArrayHandleType::WritePortalType,
NUM_COMPONENTS>;
using PortalConstType =
vtkm::exec::internal::ArrayPortalGroupVec<typename SourceArrayHandleType::PortalConstControl,
vtkm::exec::internal::ArrayPortalGroupVec<typename SourceArrayHandleType::ReadPortalType,
NUM_COMPONENTS>;
VTKM_CONT
@ -150,14 +150,14 @@ public:
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->SourceArray.GetPortalControl());
return PortalType(this->SourceArray.WritePortal());
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(this->SourceArray.GetPortalConstControl());
return PortalConstType(this->SourceArray.ReadPortal());
}
VTKM_CONT

20
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -178,18 +178,18 @@ class Storage<vtkm::VecFromPortal<SourcePortal>,
using OffsetsArrayHandleType = vtkm::cont::ArrayHandle<vtkm::Id, OffsetsStorageTag>;
VTKM_STATIC_ASSERT_MSG(
(std::is_same<SourcePortal, typename SourceArrayHandleType::PortalControl>::value),
(std::is_same<SourcePortal, typename SourceArrayHandleType::WritePortalType>::value),
"Used invalid SourcePortal type with expected SourceStorageTag.");
public:
using ValueType = vtkm::VecFromPortal<SourcePortal>;
using PortalType = vtkm::exec::internal::ArrayPortalGroupVecVariable<
typename SourceArrayHandleType::PortalControl,
typename OffsetsArrayHandleType::PortalConstControl>;
typename SourceArrayHandleType::WritePortalType,
typename OffsetsArrayHandleType::ReadPortalType>;
using PortalConstType = vtkm::exec::internal::ArrayPortalGroupVecVariable<
typename SourceArrayHandleType::PortalConstControl,
typename OffsetsArrayHandleType::PortalConstControl>;
typename SourceArrayHandleType::ReadPortalType,
typename OffsetsArrayHandleType::ReadPortalType>;
VTKM_CONT
Storage()
@ -208,15 +208,13 @@ public:
VTKM_CONT
PortalType GetPortal()
{
return PortalType(this->SourceArray.GetPortalControl(),
this->OffsetsArray.GetPortalConstControl());
return PortalType(this->SourceArray.WritePortal(), this->OffsetsArray.ReadPortal());
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
return PortalConstType(this->SourceArray.GetPortalConstControl(),
this->OffsetsArray.GetPortalConstControl());
return PortalConstType(this->SourceArray.ReadPortal(), this->OffsetsArray.ReadPortal());
}
VTKM_CONT
@ -395,7 +393,7 @@ private:
template <typename SourceArrayHandleType, typename OffsetsArrayHandleType>
class ArrayHandleGroupVecVariable
: public vtkm::cont::ArrayHandle<
vtkm::VecFromPortal<typename SourceArrayHandleType::PortalControl>,
vtkm::VecFromPortal<typename SourceArrayHandleType::WritePortalType>,
vtkm::cont::StorageTagGroupVecVariable<typename SourceArrayHandleType::StorageTag,
typename OffsetsArrayHandleType::StorageTag>>
{
@ -411,7 +409,7 @@ public:
ArrayHandleGroupVecVariable,
(ArrayHandleGroupVecVariable<SourceArrayHandleType, OffsetsArrayHandleType>),
(vtkm::cont::ArrayHandle<
vtkm::VecFromPortal<typename SourceArrayHandleType::PortalControl>,
vtkm::VecFromPortal<typename SourceArrayHandleType::WritePortalType>,
vtkm::cont::StorageTagGroupVecVariable<typename SourceArrayHandleType::StorageTag,
typename OffsetsArrayHandleType::StorageTag>>));

6
vtkm/cont/ArrayHandleImplicit.h
View File

@ -32,6 +32,8 @@ struct ArrayHandleImplicitTraits
using ValueType = decltype(FunctorType{}(vtkm::Id{}));
using StorageTag = vtkm::cont::StorageTagImplicit<ArrayPortalImplicit<FunctorType>>;
using Superclass = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
using StorageType = vtkm::cont::internal::Storage<ValueType, StorageTag>;
using PortalType = typename StorageType::PortalType;
};
/// \brief An array portal that returns the result of a functor
@ -102,7 +104,7 @@ public:
VTKM_CONT
ArrayHandleImplicit(FunctorType functor, vtkm::Id length)
: Superclass(typename Superclass::PortalConstControl(functor, length))
: Superclass(typename ArrayTraits::PortalType(functor, length))
{
}
};
@ -162,7 +164,7 @@ public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
vtkmdiy::save(bb, obj.GetNumberOfValues());
vtkmdiy::save(bb, obj.GetPortalConstControl().GetFunctor());
vtkmdiy::save(bb, obj.ReadPortal().GetFunctor());
}
static VTKM_CONT void load(BinaryBuffer& bb, BaseType& obj)

4
vtkm/cont/ArrayHandleIndex.h
View File

@ -64,7 +64,9 @@ public:
VTKM_CONT
ArrayHandleIndex(vtkm::Id length)
: Superclass(typename Superclass::PortalConstControl(internal::IndexFunctor{}, length))
: Superclass(
typename internal::Storage<vtkm::Id, StorageTagIndex>::PortalType(internal::IndexFunctor{},
length))
{
}
};

8
vtkm/cont/ArrayHandleMultiplexer.h
View File

@ -180,10 +180,10 @@ private:
using StorageToArrayHandle = vtkm::cont::ArrayHandle<ValueType, S>;
template <typename S>
using StorageToPortalControl = typename StorageToArrayHandle<S>::PortalControl;
using StorageToPortalControl = typename StorageToArrayHandle<S>::WritePortalType;
template <typename S>
using StorageToPortalConstControl = typename StorageToArrayHandle<S>::PortalConstControl;
using StorageToPortalConstControl = typename StorageToArrayHandle<S>::ReadPortalType;
using ArrayHandleVariantType = vtkm::internal::Variant<StorageToArrayHandle<StorageTags>...>;
ArrayHandleVariantType ArrayHandleVariant;
@ -231,7 +231,7 @@ private:
template <typename ArrayHandleType>
VTKM_CONT PortalType operator()(ArrayHandleType&& array) const
{
return PortalType(array.GetPortalControl());
return PortalType(array.WritePortal());
}
};
@ -240,7 +240,7 @@ private:
template <typename ArrayHandleType>
VTKM_CONT PortalConstType operator()(ArrayHandleType&& array) const
{
return PortalConstType(array.GetPortalConstControl());
return PortalConstType(array.ReadPortal());
}
};

14
vtkm/cont/ArrayHandlePermutation.h
View File

@ -124,11 +124,11 @@ public:
using ValueType = T;
using PortalType =
vtkm::exec::internal::ArrayPortalPermutation<typename IndexArrayType::PortalConstControl,
typename ValueArrayType::PortalControl>;
vtkm::exec::internal::ArrayPortalPermutation<typename IndexArrayType::ReadPortalType,
typename ValueArrayType::WritePortalType>;
using PortalConstType =
vtkm::exec::internal::ArrayPortalPermutation<typename IndexArrayType::PortalConstControl,
typename ValueArrayType::PortalConstControl>;
vtkm::exec::internal::ArrayPortalPermutation<typename IndexArrayType::ReadPortalType,
typename ValueArrayType::ReadPortalType>;
VTKM_CONT
Storage()
@ -148,16 +148,14 @@ public:
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->IndexArray.GetPortalConstControl(),
this->ValueArray.GetPortalControl());
return PortalType(this->IndexArray.ReadPortal(), this->ValueArray.WritePortal());
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(this->IndexArray.GetPortalConstControl(),
this->ValueArray.GetPortalConstControl());
return PortalConstType(this->IndexArray.ReadPortal(), this->ValueArray.ReadPortal());
}
VTKM_CONT

11
vtkm/cont/ArrayHandleReverse.h
View File

@ -123,8 +123,8 @@ class Storage<T, StorageTagReverse<ST>>
public:
using ValueType = T;
using ArrayHandleType = typename detail::ReverseTypeArg<T, ST>::ArrayHandle;
using PortalType = ArrayPortalReverse<typename ArrayHandleType::PortalControl>;
using PortalConstType = ArrayPortalReverse<typename ArrayHandleType::PortalConstControl>;
using PortalType = ArrayPortalReverse<typename ArrayHandleType::WritePortalType>;
using PortalConstType = ArrayPortalReverse<typename ArrayHandleType::ReadPortalType>;
VTKM_CONT
Storage()
@ -140,13 +140,10 @@ public:
VTKM_CONT
PortalConstType GetPortalConst() const
{
return PortalConstType(this->Array.GetPortalConstControl());
}
PortalConstType GetPortalConst() const { return PortalConstType(this->Array.ReadPortal()); }
VTKM_CONT
PortalType GetPortal() { return PortalType(this->Array.GetPortalControl()); }
PortalType GetPortal() { return PortalType(this->Array.WritePortal()); }
VTKM_CONT
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }

8
vtkm/cont/ArrayHandleSOA.h
View File

@ -182,11 +182,11 @@ struct ArrayHandleSOATraits
using IsTrueVec = std::integral_constant<bool, (NUM_COMPONENTS > 1)>;
using PortalControl = typename detail::SOAPortalChooser<ValueType,
typename BaseArrayType::PortalControl,
typename BaseArrayType::WritePortalType,
IsTrueVec>::Type;
using PortalConstControl =
typename detail::SOAPortalChooser<ValueType,
typename BaseArrayType::PortalConstControl,
typename BaseArrayType::ReadPortalType,
IsTrueVec>::Type;
template <typename Device>
@ -282,7 +282,7 @@ public:
VTKM_ASSERT(this->IsValid());
return detail::MakeSOAPortal<PortalType>(
this->Arrays, this->GetNumberOfValues(), [](BaseArrayType& array) {
return array.GetPortalControl();
return array.WritePortal();
});
}
@ -291,7 +291,7 @@ public:
VTKM_ASSERT(this->IsValid());
return detail::MakeSOAPortal<PortalConstType>(
this->Arrays, this->GetNumberOfValues(), [](const BaseArrayType& array) {
return array.GetPortalConstControl();
return array.ReadPortal();
});
}

15
vtkm/cont/ArrayHandleStreaming.h
View File

@ -120,9 +120,9 @@ public:
using ValueType = typename ArrayHandleInputType::ValueType;
using PortalType =
vtkm::cont::internal::ArrayPortalStreaming<typename ArrayHandleInputType::PortalControl>;
vtkm::cont::internal::ArrayPortalStreaming<typename ArrayHandleInputType::WritePortalType>;
using PortalConstType =
vtkm::cont::internal::ArrayPortalStreaming<typename ArrayHandleInputType::PortalConstControl>;
vtkm::cont::internal::ArrayPortalStreaming<typename ArrayHandleInputType::ReadPortalType>;
VTKM_CONT
Storage()
@ -147,15 +147,14 @@ public:
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->InputArray.GetPortalControl(), BlockSize, BlockIndex, CurBlockSize);
return PortalType(this->InputArray.WritePortal(), BlockSize, BlockIndex, CurBlockSize);
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(
this->InputArray.GetPortalConstControl(), BlockSize, BlockIndex, CurBlockSize);
return PortalConstType(this->InputArray.ReadPortal(), BlockSize, BlockIndex, CurBlockSize);
}
VTKM_CONT
@ -238,9 +237,9 @@ public:
const vtkm::Id curBlockSize)
: Superclass(StorageType(inputArray, blockIndex, blockSize, curBlockSize))
{
this->GetPortalConstControl().SetBlockIndex(blockIndex);
this->GetPortalConstControl().SetBlockSize(blockSize);
this->GetPortalConstControl().SetCurBlockSize(curBlockSize);
this->ReadPortal().SetBlockIndex(blockIndex);
this->ReadPortal().SetBlockSize(blockSize);
this->ReadPortal().SetCurBlockSize(curBlockSize);
}
VTKM_CONT

8
vtkm/cont/ArrayHandleSwizzle.h
View File

@ -195,9 +195,9 @@ class Storage<typename ResizeVectorType<typename ArrayHandleType::ValueType, Out
public:
using PortalType =
ArrayPortalSwizzle<typename ArrayHandleType::PortalControl, ArrayHandleType, OutSize>;
ArrayPortalSwizzle<typename ArrayHandleType::WritePortalType, ArrayHandleType, OutSize>;
using PortalConstType =
ArrayPortalSwizzle<typename ArrayHandleType::PortalConstControl, ArrayHandleType, OutSize>;
ArrayPortalSwizzle<typename ArrayHandleType::ReadPortalType, ArrayHandleType, OutSize>;
using MapType = typename Traits::MapType;
using ValueType = typename Traits::OutValueType;
@ -220,14 +220,14 @@ public:
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(this->Array.GetPortalConstControl(), this->Map);
return PortalConstType(this->Array.ReadPortal(), this->Map);
}
VTKM_CONT
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->Array.GetPortalControl(), this->Map);
return PortalType(this->Array.WritePortal(), this->Map);
}
VTKM_CONT

12
vtkm/cont/ArrayHandleTransform.h
View File

@ -273,7 +273,7 @@ public:
using PortalConstType =
vtkm::exec::internal::ArrayPortalTransform<ValueType,
typename ArrayHandleType::PortalConstControl,
typename ArrayHandleType::ReadPortalType,
typename FunctorManager::FunctorType>;
// Note that this array is read only, so you really should only be getting the const
@ -307,7 +307,7 @@ public:
{
VTKM_ASSERT(this->Valid);
vtkm::cont::ScopedRuntimeDeviceTracker trackerScope(vtkm::cont::DeviceAdapterTagSerial{});
return PortalConstType(this->Array.GetPortalConstControl(), this->Functor.PrepareForControl());
return PortalConstType(this->Array.ReadPortal(), this->Functor.PrepareForControl());
}
VTKM_CONT
@ -367,12 +367,12 @@ public:
using PortalType =
vtkm::exec::internal::ArrayPortalTransform<ValueType,
typename ArrayHandleType::PortalControl,
typename ArrayHandleType::WritePortalType,
typename FunctorManager::FunctorType,
typename InverseFunctorManager::FunctorType>;
using PortalConstType =
vtkm::exec::internal::ArrayPortalTransform<ValueType,
typename ArrayHandleType::PortalConstControl,
typename ArrayHandleType::ReadPortalType,
typename FunctorManager::FunctorType,
typename InverseFunctorManager::FunctorType>;
@ -398,7 +398,7 @@ public:
{
VTKM_ASSERT(this->Valid);
vtkm::cont::ScopedRuntimeDeviceTracker trackerScope(vtkm::cont::DeviceAdapterTagSerial{});
return PortalType(this->Array.GetPortalControl(),
return PortalType(this->Array.WritePortal(),
this->Functor.PrepareForControl(),
this->InverseFunctor.PrepareForControl());
}
@ -408,7 +408,7 @@ public:
{
VTKM_ASSERT(this->Valid);
vtkm::cont::ScopedRuntimeDeviceTracker trackerScope(vtkm::cont::DeviceAdapterTagSerial{});
return PortalConstType(this->Array.GetPortalConstControl(),
return PortalConstType(this->Array.ReadPortal(),
this->Functor.PrepareForControl(),
this->InverseFunctor.PrepareForControl());
}

2
vtkm/cont/ArrayHandleUniformPointCoordinates.h
View File

@ -121,7 +121,7 @@ private:
public:
static VTKM_CONT void save(BinaryBuffer& bb, const BaseType& obj)
{
auto portal = obj.GetPortalConstControl();
auto portal = obj.ReadPortal();
vtkmdiy::save(bb, portal.GetDimensions());
vtkmdiy::save(bb, portal.GetOrigin());
vtkmdiy::save(bb, portal.GetSpacing());

8
vtkm/cont/ArrayHandleView.h
View File

@ -134,8 +134,8 @@ class Storage<T, StorageTagView<ST>>
public:
using ValueType = T;
using PortalType = ArrayPortalView<typename ArrayHandleType::PortalControl>;
using PortalConstType = ArrayPortalView<typename ArrayHandleType::PortalConstControl>;
using PortalType = ArrayPortalView<typename ArrayHandleType::WritePortalType>;
using PortalConstType = ArrayPortalView<typename ArrayHandleType::ReadPortalType>;
VTKM_CONT
Storage()
@ -158,14 +158,14 @@ public:
PortalType GetPortal()
{
VTKM_ASSERT(this->Valid);
return PortalType(this->Array.GetPortalControl(), this->StartIndex, this->NumValues);
return PortalType(this->Array.WritePortal(), this->StartIndex, this->NumValues);
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Valid);
return PortalConstType(this->Array.GetPortalConstControl(), this->StartIndex, this->NumValues);
return PortalConstType(this->Array.ReadPortal(), this->StartIndex, this->NumValues);
}
VTKM_CONT

16
vtkm/cont/ArrayHandleZip.h
View File

@ -143,13 +143,14 @@ class Storage<vtkm::Pair<T1, T2>, vtkm::cont::StorageTagZip<ST1, ST2>>
public:
using ValueType = vtkm::Pair<T1, T2>;
using PortalType = vtkm::exec::internal::ArrayPortalZip<ValueType,
typename FirstHandleType::PortalControl,
typename SecondHandleType::PortalControl>;
using PortalType =
vtkm::exec::internal::ArrayPortalZip<ValueType,
typename FirstHandleType::WritePortalType,
typename SecondHandleType::WritePortalType>;
using PortalConstType =
vtkm::exec::internal::ArrayPortalZip<ValueType,
typename FirstHandleType::PortalConstControl,
typename SecondHandleType::PortalConstControl>;
typename FirstHandleType::ReadPortalType,
typename SecondHandleType::ReadPortalType>;
VTKM_CONT
Storage()
@ -168,14 +169,13 @@ public:
VTKM_CONT
PortalType GetPortal()
{
return PortalType(this->FirstArray.GetPortalControl(), this->SecondArray.GetPortalControl());
return PortalType(this->FirstArray.WritePortal(), this->SecondArray.WritePortal());
}
VTKM_CONT
PortalConstType GetPortalConst() const
{
return PortalConstType(this->FirstArray.GetPortalConstControl(),
this->SecondArray.GetPortalConstControl());
return PortalConstType(this->FirstArray.ReadPortal(), this->SecondArray.ReadPortal());
}
VTKM_CONT

4
vtkm/cont/ArrayRangeCompute.cxx
View File

@ -77,7 +77,7 @@ vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeCompute(
vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag>& array,
vtkm::cont::DeviceAdapterId)
{
vtkm::internal::ArrayPortalUniformPointCoordinates portal = array.GetPortalConstControl();
vtkm::internal::ArrayPortalUniformPointCoordinates portal = array.ReadPortal();
// In this portal we know that the min value is the first entry and the
// max value is the last entry.
@ -86,7 +86,7 @@ vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeCompute(
vtkm::cont::ArrayHandle<vtkm::Range> rangeArray;
rangeArray.Allocate(3);
vtkm::cont::ArrayHandle<vtkm::Range>::PortalControl outPortal = rangeArray.GetPortalControl();
vtkm::cont::ArrayHandle<vtkm::Range>::WritePortalType outPortal = rangeArray.WritePortal();
outPortal.Set(0, vtkm::Range(minimum[0], maximum[0]));
outPortal.Set(1, vtkm::Range(minimum[1], maximum[1]));
outPortal.Set(2, vtkm::Range(minimum[2], maximum[2]));

12
vtkm/cont/ArrayRangeCompute.h
View File

@ -131,18 +131,18 @@ VTKM_CONT inline vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeCompute(
vtkm::cont::ArrayHandle<T, ST1> firstArray = input.GetStorage().GetFirstArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(firstArray, device);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(0, componentRange);
componentRange = componentRangeArray.ReadPortal().Get(0);
result.WritePortal().Set(0, componentRange);
vtkm::cont::ArrayHandle<T, ST2> secondArray = input.GetStorage().GetSecondArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(secondArray, device);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(1, componentRange);
componentRange = componentRangeArray.ReadPortal().Get(0);
result.WritePortal().Set(1, componentRange);
vtkm::cont::ArrayHandle<T, ST3> thirdArray = input.GetStorage().GetThirdArray();
componentRangeArray = vtkm::cont::ArrayRangeCompute(thirdArray, device);
componentRange = componentRangeArray.GetPortalConstControl().Get(0);
result.GetPortalControl().Set(2, componentRange);
componentRange = componentRangeArray.ReadPortal().Get(0);
result.WritePortal().Set(2, componentRange);
return result;
}

4
vtkm/cont/ArrayRangeCompute.hxx
View File

@ -56,7 +56,7 @@ inline vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeComputeImpl(
if (input.GetNumberOfValues() < 1)
{
auto portal = range.GetPortalControl();
auto portal = range.WritePortal();
for (vtkm::IdComponent i = 0; i < VecTraits::NUM_COMPONENTS; ++i)
{
portal.Set(i, vtkm::Range());
@ -79,7 +79,7 @@ inline vtkm::cont::ArrayHandle<vtkm::Range> ArrayRangeComputeImpl(
}
else
{
auto portal = range.GetPortalControl();
auto portal = range.WritePortal();
for (vtkm::IdComponent i = 0; i < VecTraits::NUM_COMPONENTS; ++i)
{
portal.Set(i,

51
vtkm/cont/BitField.h
View File

@ -501,10 +501,17 @@ public:
using ArrayHandleType = ArrayHandle<WordTypeDefault, StorageTagBasic>;
/// The BitPortal used in the control environment.
using PortalControl = detail::BitPortal<vtkm::cont::internal::AtomicInterfaceControl>;
using WritePortalType = vtkm::cont::internal::ArrayPortalToken<
detail::BitPortal<vtkm::cont::internal::AtomicInterfaceControl>>;
/// A read-only BitPortal used in the control environment.
using PortalConstControl = detail::BitPortalConst<vtkm::cont::internal::AtomicInterfaceControl>;
using ReadPortalType = vtkm::cont::internal::ArrayPortalToken<
detail::BitPortalConst<vtkm::cont::internal::AtomicInterfaceControl>>;
using PortalControl VTKM_DEPRECATED(1.6, "Use BitField::WritePortalType instead.") =
detail::BitPortal<vtkm::cont::internal::AtomicInterfaceControl>;
using PortalConstControl VTKM_DEPRECATED(1.6, "Use ArrayBitField::ReadPortalType instead.") =
detail::BitPortalConst<vtkm::cont::internal::AtomicInterfaceControl>;
template <typename Device>
struct ExecutionTypes
@ -625,20 +632,46 @@ public:
VTKM_CONT
DeviceAdapterId GetDeviceAdapterId() const { return this->Internals->Data.GetDeviceAdapterId(); }
/// Get a portal to the data that is usable from the control environment.
VTKM_CONT
PortalControl GetPortalControl()
/// \brief Get a portal to the data that is usable from the control environment.
///
/// As long as this portal is in scope, no one else will be able to read or write the BitField.
VTKM_CONT WritePortalType WritePortal() const
{
return PortalControl{ this->Internals->Data.GetPortalControl(), this->Internals->NumberOfBits };
auto dataPortal = this->Internals->Data.WritePortal();
return WritePortalType{ dataPortal.GetToken(), dataPortal, this->Internals->NumberOfBits };
}
/// \brief Get a read-only portal to the data that is usable from the control environment.
///
/// As long as this portal is in scope, no one else will be able to write in the BitField.
VTKM_CONT ReadPortalType ReadPortal() const
{
auto dataPortal = this->Internals->Data.ReadPortal();
return ReadPortalType{ dataPortal.GetToken(), dataPortal, this->Internals->NumberOfBits };
}
VTKM_CONT
VTKM_DEPRECATED(1.6,
"Use BitField::WritePortal() instead. "
"Note that the returned portal will lock the array while it is in scope.")
detail::BitPortal<vtkm::cont::internal::AtomicInterfaceControl> GetPortalControl()
{
return detail::BitPortal<vtkm::cont::internal::AtomicInterfaceControl>{
this->Internals->Data.WritePortal(), this->Internals->NumberOfBits
};
}
/// Get a read-only portal to the data that is usable from the control
/// environment.
VTKM_CONT
PortalConstControl GetPortalConstControl() const
VTKM_DEPRECATED(1.6,
"Use BitField::ReadPortal() instead. "
"Note that the returned portal will lock the array while it is in scope.")
detail::BitPortalConst<vtkm::cont::internal::AtomicInterfaceControl> GetPortalConstControl() const
{
return PortalConstControl{ this->Internals->Data.GetPortalConstControl(),
this->Internals->NumberOfBits };
return detail::BitPortalConst<vtkm::cont::internal::AtomicInterfaceControl>{
this->Internals->Data.ReadPortal(), this->Internals->NumberOfBits
};
}
/// Prepares this BitField to be used as an input to an operation in the

8
vtkm/cont/BoundsGlobalCompute.cxx
View File

@ -29,12 +29,12 @@ vtkm::Bounds MergeBoundsGlobal(const vtkm::Bounds& local)
{
vtkm::cont::ArrayHandle<vtkm::Range> ranges;
ranges.Allocate(3);
ranges.GetPortalControl().Set(0, local.X);
ranges.GetPortalControl().Set(1, local.Y);
ranges.GetPortalControl().Set(2, local.Z);
ranges.WritePortal().Set(0, local.X);
ranges.WritePortal().Set(1, local.Y);
ranges.WritePortal().Set(2, local.Z);
ranges = vtkm::cont::detail::MergeRangesGlobal(ranges);
auto portal = ranges.GetPortalConstControl();
auto portal = ranges.ReadPortal();
return vtkm::Bounds(portal.Get(0), portal.Get(1), portal.Get(2));
}
}

4
vtkm/cont/CellLocatorBoundingIntervalHierarchy.cxx
View File

@ -266,13 +266,13 @@ void CellLocatorBoundingIntervalHierarchy::Build()
IdArrayHandle discardKeys;
IdArrayHandle segmentSizes;
segmentSizes.Allocate(1);
segmentSizes.GetPortalControl().Set(0, numCells);
segmentSizes.WritePortal().Set(0, numCells);
this->ProcessedCellIds.Allocate(numCells);
vtkm::Id cellIdsOffset = 0;
IdArrayHandle parentIndices;
parentIndices.Allocate(1);
parentIndices.GetPortalControl().Set(0, -1);
parentIndices.WritePortal().Set(0, -1);
while (!done)
{

4
vtkm/cont/CellLocatorUniformGrid.cxx
View File

@ -54,9 +54,9 @@ void CellLocatorUniformGrid::Build()
}
UniformType uniformCoords = coords.GetData().Cast<UniformType>();
this->Origin = uniformCoords.GetPortalConstControl().GetOrigin();
this->Origin = uniformCoords.ReadPortal().GetOrigin();
vtkm::Vec3f spacing = uniformCoords.GetPortalConstControl().GetSpacing();
vtkm::Vec3f spacing = uniformCoords.ReadPortal().GetSpacing();
vtkm::Vec3f unitLength;
unitLength[0] = static_cast<vtkm::FloatDefault>(this->PointDims[0] - 1);
unitLength[1] = static_cast<vtkm::FloatDefault>(this->PointDims[1] - 1);

26
vtkm/cont/CellSetExplicit.hxx
View File

@ -135,11 +135,11 @@ VTKM_CONT
void CellSetExplicit<SST, CST, OST>::GetCellPointIds(vtkm::Id cellId,
vtkm::Id* ptids) const
{
const auto offPortal = this->Data->CellPointIds.Offsets.GetPortalConstControl();
const auto offPortal = this->Data->CellPointIds.Offsets.ReadPortal();
const vtkm::Id start = offPortal.Get(cellId);
const vtkm::Id end = offPortal.Get(cellId + 1);
const vtkm::IdComponent numIndices = static_cast<vtkm::IdComponent>(end - start);
auto connPortal = this->Data->CellPointIds.Connectivity.GetPortalConstControl();
auto connPortal = this->Data->CellPointIds.Connectivity.ReadPortal();
for (vtkm::IdComponent i = 0; i < numIndices; i++)
{
ptids[i] = connPortal.Get(start + i);
@ -169,7 +169,7 @@ VTKM_CONT
vtkm::IdComponent CellSetExplicit<SST, CST, OST>
::GetNumberOfPointsInCell(vtkm::Id cellid) const
{
const auto portal = this->Data->CellPointIds.Offsets.GetPortalConstControl();
const auto portal = this->Data->CellPointIds.Offsets.ReadPortal();
return static_cast<vtkm::IdComponent>(portal.Get(cellid + 1) -
portal.Get(cellid));
}
@ -179,7 +179,7 @@ VTKM_CONT
vtkm::UInt8 CellSetExplicit<SST, CST, OST>
::GetCellShape(vtkm::Id cellid) const
{
return this->Data->CellPointIds.Shapes.GetPortalConstControl().Get(cellid);
return this->Data->CellPointIds.Shapes.ReadPortal().Get(cellid);
}
template <typename SST, typename CST, typename OST>
@ -188,11 +188,11 @@ VTKM_CONT
void CellSetExplicit<SST, CST, OST>
::GetIndices(vtkm::Id cellId, vtkm::Vec<vtkm::Id, NumVecIndices>& ids) const
{
const auto offPortal = this->Data->CellPointIds.Offsets.GetPortalConstControl();
const auto offPortal = this->Data->CellPointIds.Offsets.ReadPortal();
const vtkm::Id start = offPortal.Get(cellId);
const vtkm::Id end = offPortal.Get(cellId + 1);
const auto numCellIndices = static_cast<vtkm::IdComponent>(end - start);
const auto connPortal = this->Data->CellPointIds.Connectivity.GetPortalConstControl();
const auto connPortal = this->Data->CellPointIds.Connectivity.ReadPortal();
VTKM_LOG_IF_S(vtkm::cont::LogLevel::Warn,
numCellIndices != NumVecIndices,
@ -213,14 +213,14 @@ VTKM_CONT
void CellSetExplicit<SST, CST, OST>
::GetIndices(vtkm::Id cellId, vtkm::cont::ArrayHandle<vtkm::Id>& ids) const
{
const auto offPortal = this->Data->CellPointIds.Offsets.GetPortalConstControl();
const auto offPortal = this->Data->CellPointIds.Offsets.ReadPortal();
const vtkm::Id start = offPortal.Get(cellId);
const vtkm::Id end = offPortal.Get(cellId + 1);
const vtkm::IdComponent numIndices = static_cast<vtkm::IdComponent>(end - start);
ids.Allocate(numIndices);
auto connPortal = this->Data->CellPointIds.Connectivity.GetPortalConstControl();
auto connPortal = this->Data->CellPointIds.Connectivity.ReadPortal();
auto outIdPortal = ids.GetPortalControl();
auto outIdPortal = ids.WritePortal();
for (vtkm::IdComponent i = 0; i < numIndices; i++)
{
@ -241,7 +241,7 @@ SetFirstToZeroIfWritable(ArrayType&& array)
{
using ValueType = typename std::decay<ArrayType>::type::ValueType;
using Traits = vtkm::TypeTraits<ValueType>;
array.GetPortalControl().Set(0, Traits::ZeroInitialization());
array.WritePortal().Set(0, Traits::ZeroInitialization());
}
template <typename ArrayType>
@ -292,9 +292,9 @@ void CellSetExplicit<SST, CST, OST>::AddCell(vtkm::UInt8 cellType,
"Connectivity increased past estimated maximum connectivity.");
}
auto shapes = this->Data->CellPointIds.Shapes.GetPortalControl();
auto conn = this->Data->CellPointIds.Connectivity.GetPortalControl();
auto offsets = this->Data->CellPointIds.Offsets.GetPortalControl();
auto shapes = this->Data->CellPointIds.Shapes.WritePortal();
auto conn = this->Data->CellPointIds.Connectivity.WritePortal();
auto offsets = this->Data->CellPointIds.Offsets.WritePortal();
shapes.Set(this->Data->NumberOfCellsAdded, cellType);
for (vtkm::IdComponent iVec = 0; iVec < numVertices; ++iVec)

7
vtkm/cont/CellSetPermutation.h
View File

@ -352,18 +352,17 @@ public:
vtkm::IdComponent GetNumberOfPointsInCell(vtkm::Id cellIndex) const override
{
return this->FullCellSet.GetNumberOfPointsInCell(
this->ValidCellIds.GetPortalConstControl().Get(cellIndex));
this->ValidCellIds.ReadPortal().Get(cellIndex));
}
vtkm::UInt8 GetCellShape(vtkm::Id id) const override
{
return this->FullCellSet.GetCellShape(this->ValidCellIds.GetPortalConstControl().Get(id));
return this->FullCellSet.GetCellShape(this->ValidCellIds.ReadPortal().Get(id));
}
void GetCellPointIds(vtkm::Id id, vtkm::Id* ptids) const override
{
return this->FullCellSet.GetCellPointIds(this->ValidCellIds.GetPortalConstControl().Get(id),
ptids);
return this->FullCellSet.GetCellPointIds(this->ValidCellIds.ReadPortal().Get(id), ptids);
}
std::shared_ptr<CellSet> NewInstance() const override

2
vtkm/cont/CellSetSingleType.h
View File

@ -144,7 +144,7 @@ public:
"Inconsistent number of points in cells for CellSetSingleType.");
}
}
auto conn = this->Data->CellPointIds.Connectivity.GetPortalControl();
auto conn = this->Data->CellPointIds.Connectivity.WritePortal();
for (vtkm::IdComponent iVert = 0; iVert < numVertices; ++iVert)
{
conn.Set(this->Data->ConnectivityAdded + iVert, Traits::GetComponent(ids, iVert));

2
vtkm/cont/ColorTable.hxx
View File

@ -230,7 +230,7 @@ inline vtkm::cont::ArrayHandle<T> buildSampleHandle(vtkm::Int32 numSamples,
vtkm::cont::ArrayHandle<T> handle;
handle.Allocate(allocationSize);
auto portal = handle.GetPortalControl();
auto portal = handle.WritePortal();
vtkm::Id index = 0;
//Insert the below range first

6
vtkm/cont/DataSetBuilderRectilinear.h
View File

@ -71,9 +71,9 @@ public:
{
vtkm::cont::ArrayHandle<T> yvals, zvals;
yvals.Allocate(1);
yvals.GetPortalControl().Set(0, 0.0);
yvals.WritePortal().Set(0, 0.0);
zvals.Allocate(1);
zvals.GetPortalControl().Set(0, 0.0);
zvals.WritePortal().Set(0, 0.0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}
@ -105,7 +105,7 @@ public:
{
vtkm::cont::ArrayHandle<T> zvals;
zvals.Allocate(1);
zvals.GetPortalControl().Set(0, 0.0);
zvals.WritePortal().Set(0, 0.0);
return DataSetBuilderRectilinear::BuildDataSet(xvals, yvals, zvals, coordNm);
}

2
vtkm/cont/Field.h
View File

@ -94,7 +94,7 @@ public:
const vtkm::Id length = this->Range.GetNumberOfValues();
for (vtkm::Id i = 0; i < length; ++i)
{
range[i] = this->Range.GetPortalConstControl().Get(i);
range[i] = this->Range.ReadPortal().Get(i);
}
}

2
vtkm/cont/FieldRangeCompute.hxx
View File

@ -68,7 +68,7 @@ VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Range> FieldRangeComputeImpl(
result.resize(
std::max(result.size(), static_cast<size_t>(partition_range.GetNumberOfValues())));
auto portal = partition_range.GetPortalConstControl();
auto portal = partition_range.ReadPortal();
std::transform(vtkm::cont::ArrayPortalToIteratorBegin(portal),
vtkm::cont::ArrayPortalToIteratorEnd(portal),
result.begin(),

4
vtkm/cont/FieldRangeGlobalCompute.cxx
View File

@ -54,8 +54,8 @@ vtkm::cont::ArrayHandle<vtkm::Range> MergeRangesGlobal(
}
std::vector<vtkm::Range> v_ranges(static_cast<size_t>(ranges.GetNumberOfValues()));
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(ranges.GetPortalConstControl()),
vtkm::cont::ArrayPortalToIteratorEnd(ranges.GetPortalConstControl()),
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(ranges.ReadPortal()),
vtkm::cont::ArrayPortalToIteratorEnd(ranges.ReadPortal()),
v_ranges.begin());
using VectorOfRangesT = std::vector<vtkm::Range>;

9
vtkm/cont/StorageExtrude.h
View File

@ -98,8 +98,7 @@ class VTKM_ALWAYS_EXPORT Storage<T, internal::StorageTagExtrudePlane>
public:
using ValueType = T;
using PortalConstType =
vtkm::exec::ArrayPortalExtrudePlane<typename HandleType::PortalConstControl>;
using PortalConstType = vtkm::exec::ArrayPortalExtrudePlane<typename HandleType::ReadPortalType>;
// Note that this array is read only, so you really should only be getting the const
// version of the portal. If you actually try to write to this portal, you will
@ -126,7 +125,7 @@ public:
PortalConstType GetPortalConst() const
{
return PortalConstType(this->Array.GetPortalConstControl(), this->NumberOfPlanes);
return PortalConstType(this->Array.ReadPortal(), this->NumberOfPlanes);
}
vtkm::Id GetNumberOfValues() const
@ -377,7 +376,7 @@ class Storage<T, internal::StorageTagExtrude>
{
using BaseT = typename VecTraits<T>::BaseComponentType;
using HandleType = vtkm::cont::ArrayHandle<BaseT>;
using TPortalType = typename HandleType::PortalConstControl;
using TPortalType = typename HandleType::ReadPortalType;
public:
using ValueType = T;
@ -421,7 +420,7 @@ public:
PortalConstType GetPortalConst() const
{
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
return PortalConstType(this->Array.GetPortalConstControl(),
return PortalConstType(this->Array.ReadPortal(),
static_cast<vtkm::Int32>(this->Array.GetNumberOfValues()),
this->NumberOfPlanes,
this->UseCylindrical);

4
vtkm/cont/StorageVirtual.cxx
View File

@ -145,7 +145,7 @@ const vtkm::internal::PortalVirtualBase* StorageVirtual::PrepareForInPlace(
}
//--------------------------------------------------------------------
const vtkm::internal::PortalVirtualBase* StorageVirtual::GetPortalControl()
const vtkm::internal::PortalVirtualBase* StorageVirtual::WritePortal()
{
if (!this->HostUpToDate)
{
@ -160,7 +160,7 @@ const vtkm::internal::PortalVirtualBase* StorageVirtual::GetPortalControl()
}
//--------------------------------------------------------------------
const vtkm::internal::PortalVirtualBase* StorageVirtual::GetPortalConstControl() const
const vtkm::internal::PortalVirtualBase* StorageVirtual::ReadPortal() const
{
if (!this->HostUpToDate)
{

10
vtkm/cont/StorageVirtual.h
View File

@ -122,11 +122,11 @@ public:
//This needs to cause a host side sync!
//This needs to work before we execute on a device
const vtkm::internal::PortalVirtualBase* GetPortalControl();
const vtkm::internal::PortalVirtualBase* WritePortal();
//This needs to cause a host side sync!
//This needs to work before we execute on a device
const vtkm::internal::PortalVirtualBase* GetPortalConstControl() const;
const vtkm::internal::PortalVirtualBase* ReadPortal() const;
/// Returns the DeviceAdapterId for the current device. If there is no device
/// with an up-to-date copy of the data, VTKM_DEVICE_ADAPTER_UNDEFINED is
@ -249,14 +249,14 @@ public:
PortalType GetPortal()
{
return make_ArrayPortalRef(
static_cast<const vtkm::ArrayPortalVirtual<T>*>(this->VirtualStorage->GetPortalControl()),
static_cast<const vtkm::ArrayPortalVirtual<T>*>(this->VirtualStorage->WritePortal()),
this->GetNumberOfValues());
}
PortalConstType GetPortalConst() const
{
return make_ArrayPortalRef(static_cast<const vtkm::ArrayPortalVirtual<T>*>(
this->VirtualStorage->GetPortalConstControl()),
return make_ArrayPortalRef(
static_cast<const vtkm::ArrayPortalVirtual<T>*>(this->VirtualStorage->ReadPortal()),
this->GetNumberOfValues());
}

4
vtkm/cont/StorageVirtual.hxx
View File

@ -180,7 +180,7 @@ template <typename T, typename S>
void StorageVirtualImpl<T, S>::ControlPortalForInput(
vtkm::cont::internal::TransferInfoArray& payload) const
{
auto portal = this->Handle.GetPortalConstControl();
auto portal = this->Handle.ReadPortal();
using DerivedPortal = vtkm::ArrayPortalWrapper<decltype(portal)>;
vtkm::cont::make_hostPortal<DerivedPortal>(payload, portal);
}
@ -190,7 +190,7 @@ inline void make_writableHostPortal(std::true_type,
vtkm::cont::internal::TransferInfoArray& payload,
HandleType& handle)
{
auto portal = handle.GetPortalControl();
auto portal = handle.WritePortal();
using DerivedPortal = vtkm::ArrayPortalWrapper<decltype(portal)>;
vtkm::cont::make_hostPortal<DerivedPortal>(payload, portal);
}

2
vtkm/cont/arg/testing/UnitTestTransportArrayInOut.cxx
View File

@ -64,7 +64,7 @@ struct TryArrayInOutType
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);
token.DetachFromAll();
typename ArrayHandleType::PortalConstControl portal = handle.GetPortalConstControl();
typename ArrayHandleType::ReadPortalType portal = handle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE,
"Portal has wrong number of values.");
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)

2
vtkm/cont/arg/testing/UnitTestTransportArrayOut.cxx
View File

@ -62,7 +62,7 @@ struct TryArrayOutType
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);
token.DetachFromAll();
CheckPortal(handle.GetPortalConstControl());
CheckPortal(handle.ReadPortal());
}
};

8
vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx
View File

@ -132,7 +132,7 @@ struct TryWholeArrayType
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(outKernel, ARRAY_SIZE);
token.DetachFromAll();
CheckPortal(array.GetPortalConstControl());
CheckPortal(array.ReadPortal());
std::cout << "Check Transport WholeArrayIn" << std::endl;
TestInKernel<typename InTransportType::ExecObjectType> inKernel;
@ -152,7 +152,7 @@ struct TryWholeArrayType
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
T expectedValue = TestValue(index, T()) + T(OFFSET);
T retrievedValue = array.GetPortalConstControl().Get(index);
T retrievedValue = array.ReadPortal().Get(index);
VTKM_TEST_ASSERT(test_equal(expectedValue, retrievedValue),
"In/Out array not set correctly.");
}
@ -172,7 +172,7 @@ struct TryAtomicArrayType
ArrayHandleType array;
array.Allocate(1);
array.GetPortalControl().Set(0, 0);
array.WritePortal().Set(0, 0);
vtkm::cont::Token token;
@ -183,7 +183,7 @@ struct TryAtomicArrayType
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);
token.DetachFromAll();
T result = array.GetPortalConstControl().Get(0);
T result = array.ReadPortal().Get(0);
VTKM_TEST_ASSERT(result == ((ARRAY_SIZE - 1) * ARRAY_SIZE) / 2,
"Got wrong summation in atomic array.");
}

2
vtkm/cont/arg/testing/UnitTestTypeCheckArray.cxx
View File

@ -41,7 +41,7 @@ struct TryArraysOfType
"Composite array type check failed.");
// Just some type that is not a valid array.
using NotAnArray = typename StandardArray::PortalControl;
using NotAnArray = typename StandardArray::WritePortalType;
VTKM_TEST_ASSERT(!(TypeCheck<TypeCheckTagArray, NotAnArray>::value),
"Not an array type check failed.");

2
vtkm/cont/cuda/testing/UnitTestCudaMath.cu
View File

@ -144,7 +144,7 @@ void RunEdgeCases()
dispatcher.SetDevice(Device());
dispatcher.Invoke(bad, sane, result);
auto portal = result.GetPortalConstControl();
auto portal = result.ReadPortal();
//the first 6 values should be nan
VTKM_TEST_ASSERT(vtkm::IsNan(portal.Get(0)), "Value should be NaN.");

2
vtkm/cont/cuda/testing/UnitTestCudaShareUserProvidedManagedMemory.cu
View File

@ -209,7 +209,7 @@ void TestRoundTrip(bool managed)
try
{
handle.GetPortalControl();
handle.WritePortal();
}
catch (vtkm::cont::ErrorBadValue&)
{

4
vtkm/cont/internal/ArrayHandleBasicImpl.cxx
View File

@ -379,7 +379,7 @@ void ArrayHandleImpl::WaitToRead(LockType& lock, const vtkm::cont::Token& token)
{
// Note that if you deadlocked here, that means that you are trying to do a read operation on an
// array where an object is writing to it. This could happen on the same thread. For example, if
// you call `GetPortalControl()` then no other operation that can result in reading or writing
// you call `WritePortal()` then no other operation that can result in reading or writing
// data in the array can happen while the resulting portal is still in scope.
this->Internals->ConditionVariable.wait(
lock, [&lock, &token, this] { return this->CanRead(lock, token); });
@ -389,7 +389,7 @@ void ArrayHandleImpl::WaitToWrite(LockType& lock, const vtkm::cont::Token& token
{
// Note that if you deadlocked here, that means that you are trying to do a write operation on an
// array where an object is reading or writing to it. This could happen on the same thread. For
// example, if you call `GetPortalControl()` then no other operation that can result in reading
// example, if you call `WritePortal()` then no other operation that can result in reading
// or writing data in the array can happen while the resulting portal is still in scope.
this->Internals->ConditionVariable.wait(
lock, [&lock, &token, this] { return this->CanWrite(lock, token); });

38
vtkm/cont/internal/ArrayPortalToken.h
View File

@ -31,31 +31,47 @@ namespace internal
///
/// Because `Token`s only work in the control environment, so it is for this class.
///
template <typename PortalType>
class VTKM_ALWAYS_EXPORT ArrayPortalToken : public PortalType
template <typename PortalType_>
class VTKM_ALWAYS_EXPORT ArrayPortalToken : public PortalType_
{
std::shared_ptr<vtkm::cont::Token> Token;
using Superclass = PortalType_;
public:
template <typename... PortalArgs>
VTKM_CONT ArrayPortalToken(vtkm::cont::Token&& token, PortalArgs&... args)
: PortalType(std::forward<PortalArgs>(args)...)
VTKM_CONT ArrayPortalToken(vtkm::cont::Token&& token, PortalArgs&&... args)
: Superclass(std::forward<PortalArgs>(args)...)
, Token(new vtkm::cont::Token(std::move(token)))
{
}
template <typename... PortalArgs>
VTKM_CONT ArrayPortalToken(PortalArgs&... args)
: PortalType(std::forward<PortalArgs>(args)...)
VTKM_CONT ArrayPortalToken(std::shared_ptr<vtkm::cont::Token> token, PortalArgs&&... args)
: Superclass(std::forward<PortalArgs>(args)...)
, Token(token)
{
}
template <typename... PortalArgs>
VTKM_CONT ArrayPortalToken(PortalArgs&&... args)
: Superclass(std::forward<PortalArgs>(args)...)
, Token(new vtkm::cont::Token)
{
}
VTKM_CONT void Detach() const
{
this->Token.DetachFromAll();
this->Portal = PortalType();
}
/// \brief Detach this portal from the `ArrayHandle`.
///
/// This will open up the `ArrayHandle` for reading and/or writing.
///
VTKM_CONT void Detach() { this->Token->DetachFromAll(); }
/// \brief Get the `Token` of the `ArrayPortal`.
///
/// You can keep a copy of this shared pointer to keep the scope around longer than this
/// object exists (unless, of course, the `Token` is explicitly detached).
///
VTKM_CONT std::shared_ptr<vtkm::cont::Token> GetToken() const { return this->Token; }
};
}
}

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

@ -114,7 +114,7 @@ private:
DerivedAlgorithm::Schedule(kernel, 1);
}
return output.GetPortalConstControl().Get(0);
return output.ReadPortal().Get(0);
}
public:
@ -748,7 +748,7 @@ public:
if (numValues <= 0)
{
output.Allocate(1);
output.GetPortalControl().Set(0, initialValue);
output.WritePortal().Set(0, initialValue);
return;
}
@ -808,7 +808,7 @@ public:
else if (numberOfKeys == 1)
{
output.Allocate(1);
output.GetPortalControl().Set(0, initialValue);
output.WritePortal().Set(0, initialValue);
return;
}

2
vtkm/cont/internal/VariantArrayHandleContainer.h
View File

@ -122,7 +122,7 @@ private:
{
return (this->Array.GetNumberOfValues() == 0)
? 0
: vtkm::VecTraits<T>::GetNumberOfComponents(this->Array.GetPortalConstControl().Get(0));
: vtkm::VecTraits<T>::GetNumberOfComponents(this->Array.ReadPortal().Get(0));
}
};

6
vtkm/cont/testing/MakeTestDataSet.h
View File

@ -1509,7 +1509,7 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose()
for (vtkm::Id i = 0; i < connectivitySize; ++i)
{
connectivity.GetPortalControl().Set(i, pointId[i]);
connectivity.WritePortal().Set(i, pointId[i]);
}
vtkm::cont::CellSetSingleType<> cellSet;
cellSet.Fill(nVerts, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity);
@ -1522,11 +1522,11 @@ inline vtkm::cont::DataSet MakeTestDataSet::Make3DExplicitDataSetCowNose()
vtkm::cont::ArrayHandle<vtkm::Vec3f> pointvec;
pointvec.Allocate(nVerts);
SetPortal(pointvec.GetPortalControl());
SetPortal(pointvec.WritePortal());
vtkm::cont::ArrayHandle<vtkm::Vec3f> cellvec;
cellvec.Allocate(connectivitySize / 3);
SetPortal(cellvec.GetPortalControl());
SetPortal(cellvec.WritePortal());
vtkm::cont::DataSetFieldAdd dsf;
dsf.AddPointField(dataSet, "pointvar", pointvar);

4
vtkm/cont/testing/Testing.h
View File

@ -178,8 +178,8 @@ struct TestEqualArrayHandle
result.PushMessage("sizes don't match");
return;
}
auto portal1 = array1.GetPortalConstControl();
auto portal2 = array2.GetPortalConstControl();
auto portal1 = array1.ReadPortal();
auto portal2 = array2.ReadPortal();
for (vtkm::Id i = 0; i < portal1.GetNumberOfValues(); ++i)
{
if (!test_equal(portal1.Get(i), portal2.Get(i)))

6
vtkm/cont/testing/TestingArrayHandleMultiplexer.h
View File

@ -45,14 +45,12 @@ class TestingArrayHandleMultiplexer
using T = typename std::remove_reference<decltype(multiplexerArray)>::type::ValueType;
vtkm::cont::printSummary_ArrayHandle(multiplexerArray, std::cout);
VTKM_TEST_ASSERT(test_equal_portals(multiplexerArray.GetPortalConstControl(),
expectedArray.GetPortalConstControl()),
VTKM_TEST_ASSERT(test_equal_portals(multiplexerArray.ReadPortal(), expectedArray.ReadPortal()),
"Multiplexer array gave wrong result in control environment");
vtkm::cont::ArrayHandle<T> copy;
vtkm::cont::ArrayCopy(multiplexerArray, copy);
VTKM_TEST_ASSERT(
test_equal_portals(copy.GetPortalConstControl(), expectedArray.GetPortalConstControl()),
VTKM_TEST_ASSERT(test_equal_portals(copy.ReadPortal(), expectedArray.ReadPortal()),
"Multiplexer did not copy correctly in execution environment");
}

12
vtkm/cont/testing/TestingArrayHandleVirtualCoordinates.h
View File

@ -60,7 +60,7 @@ inline void TestVirtualAccess(const vtkm::cont::ArrayHandle<T, S>& in,
vtkm::worklet::DispatcherMapField<CopyWorklet>().Invoke(
vtkm::cont::ArrayHandleVirtualCoordinates(in), vtkm::cont::ArrayHandleVirtualCoordinates(out));
VTKM_TEST_ASSERT(test_equal_portals(in.GetPortalConstControl(), out.GetPortalConstControl()),
VTKM_TEST_ASSERT(test_equal_portals(in.ReadPortal(), out.ReadPortal()),
"Input and output portals don't match");
}
@ -90,7 +90,7 @@ private:
a1.Allocate(length);
for (vtkm::Id i = 0; i < length; ++i)
{
a1.GetPortalControl().Set(i, TestValue(i, PointType()));
a1.WritePortal().Set(i, TestValue(i, PointType()));
}
TestVirtualAccess(a1, out);
@ -105,10 +105,10 @@ private:
c3.Allocate(length);
for (vtkm::Id i = 0; i < length; ++i)
{
auto p = a1.GetPortalConstControl().Get(i);
c1.GetPortalControl().Set(i, p[0]);
c2.GetPortalControl().Set(i, p[1]);
c3.GetPortalControl().Set(i, p[2]);
auto p = a1.ReadPortal().Get(i);
c1.WritePortal().Set(i, p[0]);
c2.WritePortal().Set(i, p[1]);
c3.WritePortal().Set(i, p[2]);
}
TestVirtualAccess(vtkm::cont::make_ArrayHandleCartesianProduct(c1, c2, c3), out);

13
vtkm/cont/testing/TestingArrayHandles.h
View File

@ -55,7 +55,7 @@ void CheckValues(IteratorType begin, IteratorType end, T)
template <typename T>
void CheckArray(const vtkm::cont::ArrayHandle<T>& handle)
{
CheckPortal(handle.GetPortalConstControl());
CheckPortal(handle.ReadPortal());
}
}
@ -139,7 +139,7 @@ private:
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == 0,
"Uninitialized array does not report zero values.");
arrayHandle = vtkm::cont::ArrayHandle<T>();
VTKM_TEST_ASSERT(arrayHandle.GetPortalConstControl().GetNumberOfValues() == 0,
VTKM_TEST_ASSERT(arrayHandle.ReadPortal().GetNumberOfValues() == 0,
"Uninitialized array does not give portal with zero values.");
vtkm::cont::Token token;
arrayHandle = vtkm::cont::ArrayHandle<T>();
@ -226,7 +226,7 @@ private:
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
token.DetachFromAll();
arrayHandle.GetPortalControl();
arrayHandle.WritePortal();
}
catch (vtkm::cont::Error&)
{
@ -313,7 +313,7 @@ private:
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
token.DetachFromAll();
arrayHandle.GetPortalControl();
arrayHandle.WritePortal();
}
catch (vtkm::cont::Error&)
{
@ -377,8 +377,7 @@ private:
InplaceFunctor<T, ExecutionPortalType> functor(executionPortal);
Algorithm::Schedule(functor, ARRAY_SIZE * 2);
}
typename vtkm::cont::ArrayHandle<T>::PortalConstControl controlPortal =
arrayHandle.GetPortalConstControl();
typename vtkm::cont::ArrayHandle<T>::ReadPortalType controlPortal = arrayHandle.ReadPortal();
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(test_equal(controlPortal.Get(index), TestValue(index, T()) + T(1)),
@ -411,7 +410,7 @@ private:
VTKM_TEST_ASSERT(a1 == a2, "Shallow copied array not equal.");
VTKM_TEST_ASSERT(!(a1 != a2), "Shallow copied array not equal.");
a1.GetPortalConstControl();
a1.ReadPortal();
VTKM_TEST_ASSERT(a1 == a2, "Shallow copied array not equal.");
VTKM_TEST_ASSERT(!(a1 != a2), "Shallow copied array not equal.");

110
vtkm/cont/testing/TestingBitField.h
View File

@ -135,7 +135,7 @@ struct TestingBitField
{
BitField field;
field.Allocate(numBits);
auto portal = field.GetPortalControl();
auto portal = field.WritePortal();
for (vtkm::Id i = 0; i < numBits; ++i)
{
portal.SetBit(i, RandomBitFromIndex(i));
@ -166,8 +166,8 @@ struct TestingBitField
"memory.");
}
template <typename PortalType, typename PortalConstType>
VTKM_EXEC_CONT static bool HelpTestBit(vtkm::Id i, PortalType portal, PortalConstType portalConst)
template <typename PortalType>
VTKM_EXEC_CONT static bool HelpTestBit(vtkm::Id i, PortalType portal)
{
const auto origBit = RandomBitFromIndex(i);
auto bit = origBit;
@ -177,9 +177,7 @@ struct TestingBitField
auto testValues = [&](const char* op) -> bool {
auto expected = bit;
auto result = portal.GetBitAtomic(i);
auto resultConst = portalConst.GetBitAtomic(i);
DEVICE_ASSERT_MSG(result == expected, op);
DEVICE_ASSERT_MSG(resultConst == expected, op);
// Reset:
bit = origBit;
@ -211,19 +209,15 @@ struct TestingBitField
bool casResult = portal.CompareAndSwapBitAtomic(i, bit, notBit);
DEVICE_ASSERT(casResult == bit);
DEVICE_ASSERT(portal.GetBit(i) == bit);
DEVICE_ASSERT(portalConst.GetBit(i) == bit);
casResult = portal.CompareAndSwapBitAtomic(i, notBit, bit);
DEVICE_ASSERT(casResult == bit);
DEVICE_ASSERT(portal.GetBit(i) == notBit);
DEVICE_ASSERT(portalConst.GetBit(i) == notBit);
return true;
}
template <typename WordType, typename PortalType, typename PortalConstType>
VTKM_EXEC_CONT static bool HelpTestWord(vtkm::Id i,
PortalType portal,
PortalConstType portalConst)
template <typename WordType, typename PortalType>
VTKM_EXEC_CONT static bool HelpTestWord(vtkm::Id i, PortalType portal)
{
const auto origWord = RandomWordFromIndex<WordType>(i);
auto word = origWord;
@ -233,9 +227,7 @@ struct TestingBitField
auto testValues = [&](const char* op) -> bool {
auto expected = word;
auto result = portal.template GetWordAtomic<WordType>(i);
auto resultConst = portalConst.template GetWordAtomic<WordType>(i);
DEVICE_ASSERT_MSG(result == expected, op);
DEVICE_ASSERT_MSG(resultConst == expected, op);
// Reset:
word = origWord;
@ -273,25 +265,21 @@ struct TestingBitField
auto casResult = portal.CompareAndSwapWordAtomic(i, word, notWord);
DEVICE_ASSERT(casResult == word);
DEVICE_ASSERT(portal.template GetWord<WordType>(i) == word);
DEVICE_ASSERT(portalConst.template GetWord<WordType>(i) == word);
casResult = portal.CompareAndSwapWordAtomic(i, notWord, word);
DEVICE_ASSERT(casResult == word);
DEVICE_ASSERT(portal.template GetWord<WordType>(i) == notWord);
DEVICE_ASSERT(portalConst.template GetWord<WordType>(i) == notWord);
return true;
}
template <typename PortalType, typename PortalConstType>
template <typename PortalType>
struct HelpTestWordOpsControl
{
PortalType Portal;
PortalConstType PortalConst;
VTKM_CONT
HelpTestWordOpsControl(PortalType portal, PortalConstType portalConst)
HelpTestWordOpsControl(PortalType portal)
: Portal(portal)
, PortalConst(portalConst)
{
}
@ -299,16 +287,15 @@ struct TestingBitField
VTKM_CONT void operator()(WordType)
{
const auto numWords = this->Portal.template GetNumberOfWords<WordType>();
VTKM_TEST_ASSERT(numWords == this->PortalConst.template GetNumberOfWords<WordType>());
for (vtkm::Id i = 0; i < numWords; ++i)
{
VTKM_TEST_ASSERT(HelpTestWord<WordType>(i, this->Portal, this->PortalConst));
VTKM_TEST_ASSERT(HelpTestWord<WordType>(i, this->Portal));
}
}
};
template <typename Portal, typename PortalConst>
VTKM_CONT static void HelpTestPortalsControl(Portal portal, PortalConst portalConst)
template <typename Portal>
VTKM_CONT static void HelpTestPortalsControl(Portal portal)
{
const auto numWords8 = (NUM_BITS + 7) / 8;
const auto numWords16 = (NUM_BITS + 15) / 16;
@ -320,18 +307,13 @@ struct TestingBitField
VTKM_TEST_ASSERT(portal.template GetNumberOfWords<vtkm::UInt16>() == numWords16);
VTKM_TEST_ASSERT(portal.template GetNumberOfWords<vtkm::UInt32>() == numWords32);
VTKM_TEST_ASSERT(portal.template GetNumberOfWords<vtkm::UInt64>() == numWords64);
VTKM_TEST_ASSERT(portalConst.GetNumberOfBits() == NUM_BITS);
VTKM_TEST_ASSERT(portalConst.template GetNumberOfWords<vtkm::UInt8>() == numWords8);
VTKM_TEST_ASSERT(portalConst.template GetNumberOfWords<vtkm::UInt16>() == numWords16);
VTKM_TEST_ASSERT(portalConst.template GetNumberOfWords<vtkm::UInt32>() == numWords32);
VTKM_TEST_ASSERT(portalConst.template GetNumberOfWords<vtkm::UInt64>() == numWords64);
for (vtkm::Id i = 0; i < NUM_BITS; ++i)
{
HelpTestBit(i, portal, portalConst);
HelpTestBit(i, portal);
}
HelpTestWordOpsControl<Portal, PortalConst> test(portal, portalConst);
HelpTestWordOpsControl<Portal> test(portal);
vtkm::ListForEach(test, typename Portal::AtomicInterface::WordTypes{});
}
@ -339,10 +321,8 @@ struct TestingBitField
static void TestControlPortals()
{
auto field = RandomBitField();
auto portal = field.GetPortalControl();
auto portalConst = field.GetPortalConstControl();
HelpTestPortalsControl(portal, portalConst);
HelpTestPortalsControl(field.WritePortal());
}
template <typename Portal>
@ -362,15 +342,13 @@ struct TestingBitField
return true;
}
template <typename WordType, typename PortalType, typename PortalConstType>
template <typename WordType, typename PortalType>
struct HelpTestPortalsExecutionWordsFunctor : vtkm::exec::FunctorBase
{
PortalType Portal;
PortalConstType PortalConst;
HelpTestPortalsExecutionWordsFunctor(PortalType portal, PortalConstType portalConst)
HelpTestPortalsExecutionWordsFunctor(PortalType portal)
: Portal(portal)
, PortalConst(portalConst)
{
}
@ -384,14 +362,9 @@ struct TestingBitField
this->RaiseError("Testing Portal sanity failed.");
return;
}
if (!HelpTestPortalSanityExecution(this->PortalConst))
{
this->RaiseError("Testing PortalConst sanity failed.");
return;
}
}
if (!HelpTestWord<WordType>(i, this->Portal, this->PortalConst))
if (!HelpTestWord<WordType>(i, this->Portal))
{
this->RaiseError("Testing word operations failed.");
return;
@ -399,22 +372,20 @@ struct TestingBitField
}
};
template <typename PortalType, typename PortalConstType>
template <typename PortalType>
struct HelpTestPortalsExecutionBitsFunctor : vtkm::exec::FunctorBase
{
PortalType Portal;
PortalConstType PortalConst;
HelpTestPortalsExecutionBitsFunctor(PortalType portal, PortalConstType portalConst)
HelpTestPortalsExecutionBitsFunctor(PortalType portal)
: Portal(portal)
, PortalConst(portalConst)
{
}
VTKM_EXEC_CONT
void operator()(vtkm::Id i) const
{
if (!HelpTestBit(i, this->Portal, this->PortalConst))
if (!HelpTestBit(i, this->Portal))
{
this->RaiseError("Testing bit operations failed.");
return;
@ -422,16 +393,14 @@ struct TestingBitField
}
};
template <typename PortalType, typename PortalConstType>
template <typename PortalType>
struct HelpTestWordOpsExecution
{
PortalType Portal;
PortalConstType PortalConst;
VTKM_CONT
HelpTestWordOpsExecution(PortalType portal, PortalConstType portalConst)
HelpTestWordOpsExecution(PortalType portal)
: Portal(portal)
, PortalConst(portalConst)
{
}
@ -439,23 +408,21 @@ struct TestingBitField
VTKM_CONT void operator()(WordType)
{
const auto numWords = this->Portal.template GetNumberOfWords<WordType>();
VTKM_TEST_ASSERT(numWords == this->PortalConst.template GetNumberOfWords<WordType>());
using WordFunctor =
HelpTestPortalsExecutionWordsFunctor<WordType, PortalType, PortalConstType>;
WordFunctor test{ this->Portal, this->PortalConst };
using WordFunctor = HelpTestPortalsExecutionWordsFunctor<WordType, PortalType>;
WordFunctor test{ this->Portal };
Algo::Schedule(test, numWords);
}
};
template <typename Portal, typename PortalConst>
VTKM_CONT static void HelpTestPortalsExecution(Portal portal, PortalConst portalConst)
template <typename Portal>
VTKM_CONT static void HelpTestPortalsExecution(Portal portal)
{
HelpTestPortalsExecutionBitsFunctor<Portal, PortalConst> bitTest{ portal, portalConst };
HelpTestPortalsExecutionBitsFunctor<Portal> bitTest{ portal };
Algo::Schedule(bitTest, portal.GetNumberOfBits());
HelpTestWordOpsExecution<Portal, PortalConst> test(portal, portalConst);
HelpTestWordOpsExecution<Portal> test(portal);
vtkm::ListForEach(test, typename Portal::AtomicInterface::WordTypes{});
}
@ -465,9 +432,8 @@ struct TestingBitField
vtkm::cont::Token token;
auto field = RandomBitField();
auto portal = field.PrepareForInPlace(DeviceAdapterTag{}, token);
auto portalConst = field.PrepareForInput(DeviceAdapterTag{}, token);
HelpTestPortalsExecution(portal, portalConst);
HelpTestPortalsExecution(portal);
}
VTKM_CONT
@ -476,7 +442,7 @@ struct TestingBitField
auto testMask32 = [](vtkm::Id numBits, vtkm::UInt32 expectedMask) {
vtkm::cont::BitField field;
field.Allocate(numBits);
auto mask = field.GetPortalConstControl().GetFinalWordMask<vtkm::UInt32>();
auto mask = field.ReadPortal().GetFinalWordMask<vtkm::UInt32>();
VTKM_TEST_ASSERT(expectedMask == mask,
"Unexpected mask for BitField size ",
@ -491,7 +457,7 @@ struct TestingBitField
auto testMask64 = [](vtkm::Id numBits, vtkm::UInt64 expectedMask) {
vtkm::cont::BitField field;
field.Allocate(numBits);
auto mask = field.GetPortalConstControl().GetFinalWordMask<vtkm::UInt64>();
auto mask = field.ReadPortal().GetFinalWordMask<vtkm::UInt64>();
VTKM_TEST_ASSERT(expectedMask == mask,
"Unexpected mask for BitField size ",
@ -602,10 +568,10 @@ struct TestingBitField
vtkm::cont::Invoker invoke;
invoke(ConditionalMergeWorklet{}, condArray, trueArray, falseArray, output);
auto condVals = condArray.GetPortalConstControl();
auto trueVals = trueArray.GetPortalConstControl();
auto falseVals = falseArray.GetPortalConstControl();
auto outVals = output.GetPortalConstControl();
auto condVals = condArray.ReadPortal();
auto trueVals = trueArray.ReadPortal();
auto falseVals = falseArray.ReadPortal();
auto outVals = output.ReadPortal();
VTKM_TEST_ASSERT(condVals.GetNumberOfValues() == trueVals.GetNumberOfValues());
VTKM_TEST_ASSERT(condVals.GetNumberOfValues() == falseVals.GetNumberOfValues());
@ -628,10 +594,10 @@ struct TestingBitField
vtkm::cont::Invoker invoke;
invoke(ConditionalMergeWorklet2{}, condBits, trueArray, falseArray, output);
auto condVals = condBits.GetPortalConstControl();
auto trueVals = trueArray.GetPortalConstControl();
auto falseVals = falseArray.GetPortalConstControl();
auto outVals = output.GetPortalConstControl();
auto condVals = condBits.ReadPortal();
auto trueVals = trueArray.ReadPortal();
auto falseVals = falseArray.ReadPortal();
auto outVals = output.ReadPortal();
VTKM_TEST_ASSERT(condVals.GetNumberOfBits() == trueVals.GetNumberOfValues());
VTKM_TEST_ASSERT(condVals.GetNumberOfBits() == falseVals.GetNumberOfValues());

2
vtkm/cont/testing/TestingCellLocatorRectilinearGrid.h
View File

@ -184,7 +184,7 @@ public:
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(points, locator, cellIds, parametric, match);
auto matchPortal = match.GetPortalConstControl();
auto matchPortal = match.ReadPortal();
for (vtkm::Id index = 0; index < match.GetNumberOfValues(); index++)
{
VTKM_TEST_ASSERT(matchPortal.Get(index), "Points do not match");

13
vtkm/cont/testing/TestingCellLocatorUniformBins.h
View File

@ -95,7 +95,7 @@ vtkm::cont::DataSet MakeTestDataSet(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dims)
// Warp the coordinates
std::uniform_real_distribution<vtkm::FloatDefault> warpFactor(-0.10f, 0.10f);
auto pointsPortal = points.GetPortalControl();
auto pointsPortal = points.WritePortal();
for (vtkm::Id i = 0; i < pointsPortal.GetNumberOfValues(); ++i)
{
PointType warpVec(0);
@ -130,7 +130,7 @@ void GenerateRandomInput(const vtkm::cont::DataSet& ds,
for (vtkm::Id i = 0; i < count; ++i)
{
cellIds.GetPortalControl().Set(i, cellIdGen(RandomGenerator));
cellIds.WritePortal().Set(i, cellIdGen(RandomGenerator));
PointType pc(0.0f);
vtkm::FloatDefault minPc = 1e-2f;
@ -143,7 +143,7 @@ void GenerateRandomInput(const vtkm::cont::DataSet& ds,
pc[c] = pcoordGen(RandomGenerator);
sum += pc[c];
}
pcoords.GetPortalControl().Set(i, pc);
pcoords.WritePortal().Set(i, pc);
}
vtkm::worklet::DispatcherMapTopology<ParametricToWorldCoordinates> dispatcher(
@ -198,12 +198,9 @@ void TestCellLocator(const vtkm::Vec<vtkm::Id, DIMENSIONS>& dim, vtkm::Id number
for (vtkm::Id i = 0; i < numberOfPoints; ++i)
{
VTKM_TEST_ASSERT(cellIds.GetPortalConstControl().Get(i) ==
expCellIds.GetPortalConstControl().Get(i),
VTKM_TEST_ASSERT(cellIds.ReadPortal().Get(i) == expCellIds.ReadPortal().Get(i),
"Incorrect cell ids");
VTKM_TEST_ASSERT(test_equal(pcoords.GetPortalConstControl().Get(i),
expPCoords.GetPortalConstControl().Get(i),
1e-3),
VTKM_TEST_ASSERT(test_equal(pcoords.ReadPortal().Get(i), expPCoords.ReadPortal().Get(i), 1e-3),
"Incorrect parameteric coordinates");
}
}

2
vtkm/cont/testing/TestingCellLocatorUniformGrid.h
View File

@ -149,7 +149,7 @@ public:
dispatcher.SetDevice(DeviceAdapter());
dispatcher.Invoke(points, locator, cellIds, parametric, match);
auto matchPortal = match.GetPortalConstControl();
auto matchPortal = match.ReadPortal();
for (vtkm::Id index = 0; index < match.GetNumberOfValues(); index++)
{
VTKM_TEST_ASSERT(matchPortal.Get(index), "Points do not match");

211
vtkm/cont/testing/TestingColorTable.h
View File

@ -35,6 +35,23 @@ template <typename DeviceAdapterTag>
class TestingColorTable
{
template <vtkm::IdComponent N>
static void CheckColors(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::UInt8, N>> result,
const std::vector<vtkm::Vec<vtkm::UInt8, N>>& expected)
{
using Vec = vtkm::Vec<vtkm::UInt8, N>;
VTKM_TEST_ASSERT(result.GetNumberOfValues() == static_cast<vtkm::Id>(expected.size()));
auto portal = result.ReadPortal();
for (vtkm::Id index = 0; index < portal.GetNumberOfValues(); ++index)
{
Vec resultValue = portal.Get(index);
Vec expectedValue = expected[static_cast<std::size_t>(index)];
VTKM_TEST_ASSERT(
resultValue == expectedValue, "Expected color ", expectedValue, " but got ", resultValue);
}
}
public:
static void TestConstructors()
{
@ -150,6 +167,8 @@ public:
static void TestClamping()
{
std::cout << "Test Clamping" << std::endl;
vtkm::Range range{ 0.0, 1.0 };
vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f };
@ -167,19 +186,13 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//verify that we clamp the values to the expected range
const vtkm::Vec3ui_8 correct[nvals] = {
{ 0, 255, 0 }, { 0, 255, 0 }, { 255, 0, 255 }, { 255, 0, 255 }
};
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct[i], "incorrect value in color from clamp test");
}
CheckColors(colors, { { 0, 255, 0 }, { 0, 255, 0 }, { 255, 0, 255 }, { 255, 0, 255 } });
}
static void TestRangeColors()
{
std::cout << "Test default ranges" << std::endl;
vtkm::Range range{ -1.0, 2.0 };
vtkm::Vec<float, 3> rgb1{ 0.0f, 1.0f, 0.0f };
vtkm::Vec<float, 3> rgb2{ 1.0f, 0.0f, 1.0f };
@ -199,37 +212,21 @@ public:
//verify that both the above and below range colors are used,
//and that the default value of both is 0,0,0
const vtkm::Vec3ui_8 correct_range_defaults[nvals] = {
{ 0, 0, 0 }, { 0, 255, 0 }, { 255, 0, 255 }, { 0, 0, 0 }
};
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_range_defaults[i],
"incorrect value in color from default range color test");
}
CheckColors(colors, { { 0, 0, 0 }, { 0, 255, 0 }, { 255, 0, 255 }, { 0, 0, 0 } });
std::cout << "Test specified ranges" << std::endl;
//verify that we can specify custom above and below range colors
table.SetAboveRangeColor(vtkm::Vec<float, 3>{ 1.0f, 0.0f, 0.0f }); //red
table.SetBelowRangeColor(vtkm::Vec<float, 3>{ 0.0f, 0.0f, 1.0f }); //green
const bool ran2 = table.Map(field, colors);
VTKM_TEST_ASSERT(ran2, "color table failed to execute");
const vtkm::Vec3ui_8 correct_custom_range_colors[nvals] = {
{ 0, 0, 255 }, { 0, 255, 0 }, { 255, 0, 255 }, { 255, 0, 0 }
};
portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_custom_range_colors[i],
"incorrect value in custom above/below range color test");
}
CheckColors(colors, { { 0, 0, 255 }, { 0, 255, 0 }, { 255, 0, 255 }, { 255, 0, 0 } });
}
static void TestRescaleRange()
{
std::cout << "Test Rescale Range" << std::endl;
vtkm::Range range{ -100.0, 100.0 };
//implement a blue2yellow color table
@ -261,20 +258,19 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//values confirmed with ParaView 5.4
const vtkm::Vec3ui_8 correct_lab_values[nvals] = { { 0, 0, 255 }, { 105, 69, 204 },
{ 126, 109, 153 }, { 156, 151, 117 },
{ 207, 202, 87 }, { 255, 255, 0 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_lab_values[i],
"incorrect value in color after rescaling the color table");
}
CheckColors(colors,
{ { 0, 0, 255 },
{ 105, 69, 204 },
{ 126, 109, 153 },
{ 156, 151, 117 },
{ 207, 202, 87 },
{ 255, 255, 0 } });
}
static void TestAddPoints()
{
std::cout << "Test Add Points" << std::endl;
vtkm::Range range{ -20, 20.0 };
auto rgbspace = vtkm::cont::ColorSpace::RGB;
@ -296,20 +292,13 @@ public:
const bool ran = table.Map(field, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");
const vtkm::Vec3ui_8 correct_rgb_values[nvals] = { { 0, 0, 128 },
{ 0, 128, 255 },
{ 128, 255, 255 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_rgb_values[i],
"incorrect value when interpolating between values");
}
CheckColors(colors, { { 0, 0, 128 }, { 0, 128, 255 }, { 128, 255, 255 } });
}
static void TestAddSegments()
{
std::cout << "Test Add Segments" << std::endl;
vtkm::Range range{ 0.0, 50.0 };
auto diverging = vtkm::cont::ColorSpace::DIVERGING;
@ -342,21 +331,19 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//values confirmed with ParaView 5.4
const vtkm::Vec4ui_8 correct_diverging_values[nvals] = {
{ 59, 76, 192, 0 }, { 124, 159, 249, 51 }, { 192, 212, 245, 102 },
{ 242, 203, 183, 153 }, { 238, 133, 104, 204 }, { 180, 4, 38, 255 }
};
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_diverging_values[i],
"incorrect value when interpolating between values");
}
CheckColors(colors,
{ { 59, 76, 192, 0 },
{ 124, 159, 249, 51 },
{ 192, 212, 245, 102 },
{ 242, 203, 183, 153 },
{ 238, 133, 104, 204 },
{ 180, 4, 38, 255 } });
}
static void TestRemovePoints()
{
std::cout << "Test Remove Points" << std::endl;
auto hsv = vtkm::cont::ColorSpace::HSV;
vtkm::cont::ColorTable table(hsv);
@ -388,35 +375,32 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//values confirmed with ParaView 5.4
const vtkm::Vec3ui_8 correct_hsv_values[nvals] = { { 0, 0, 255 }, { 0, 204, 255 },
{ 0, 255, 102 }, { 102, 255, 0 },
{ 255, 204, 0 }, { 255, 0, 0 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_hsv_values[i],
"incorrect value when interpolating between values");
}
CheckColors(colors,
{ { 0, 0, 255 },
{ 0, 204, 255 },
{ 0, 255, 102 },
{ 102, 255, 0 },
{ 255, 204, 0 },
{ 255, 0, 0 } });
std::cout << " Change Color Space" << std::endl;
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors_rgb;
table.SetColorSpace(vtkm::cont::ColorSpace::RGB);
table.Map(field, colors_rgb);
const vtkm::Vec3ui_8 correct_rgb_values[nvals] = { { 0, 0, 255 }, { 51, 0, 204 },
{ 102, 0, 153 }, { 153, 0, 102 },
{ 204, 0, 51 }, { 255, 0, 0 } };
auto rgb_portal = colors_rgb.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = rgb_portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_rgb_values[i],
"incorrect value when interpolating between values");
}
CheckColors(colors_rgb,
{ { 0, 0, 255 },
{ 51, 0, 204 },
{ 102, 0, 153 },
{ 153, 0, 102 },
{ 204, 0, 51 },
{ 255, 0, 0 } });
}
static void TestOpacityOnlyPoints()
{
std::cout << "Test Opacity Only Points" << std::endl;
auto hsv = vtkm::cont::ColorSpace::HSV;
vtkm::cont::ColorTable table(hsv);
@ -449,20 +433,19 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//values confirmed with ParaView 5.4
const vtkm::Vec4ui_8 correct_opacity_values[nvals] = { { 0, 0, 0, 0 }, { 0, 0, 0, 1 },
{ 0, 0, 0, 11 }, { 0, 0, 0, 52 },
{ 0, 0, 0, 203 }, { 0, 0, 0, 255 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_opacity_values[i],
"incorrect value when interpolating between opacity values");
}
CheckColors(colors,
{ { 0, 0, 0, 0 },
{ 0, 0, 0, 1 },
{ 0, 0, 0, 11 },
{ 0, 0, 0, 52 },
{ 0, 0, 0, 203 },
{ 0, 0, 0, 255 } });
}
static void TestWorkletTransport()
{
std::cout << "Test Worklet Transport" << std::endl;
using namespace vtkm::worklet::colorconversion;
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::GREEN);
@ -484,21 +467,12 @@ public:
dispatcher.Invoke(samples, colors);
}
const vtkm::Vec4ui_8 correct_sampling_points[nvals] = { { 14, 28, 31, 255 },
{ 21, 150, 21, 255 },
{ 255, 251, 230, 255 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_sampling_points[i],
"incorrect value when interpolating in linear green preset");
}
CheckColors(colors, { { 14, 28, 31, 255 }, { 21, 150, 21, 255 }, { 255, 251, 230, 255 } });
}
static void TestSampling()
{
std::cout << "Test Sampling" << std::endl;
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::GREEN);
VTKM_TEST_ASSERT((table.GetRange() == vtkm::Range{ 0.0, 1.0 }),
@ -508,22 +482,15 @@ public:
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
constexpr vtkm::Id nvals = 3;
table.Sample(3, colors);
table.Sample(nvals, colors);
const vtkm::Vec4ui_8 correct_sampling_points[nvals] = { { 14, 28, 31, 255 },
{ 21, 150, 21, 255 },
{ 255, 251, 230, 255 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_sampling_points[i],
"incorrect value when interpolating in linear green preset");
}
CheckColors(colors, { { 14, 28, 31, 255 }, { 21, 150, 21, 255 }, { 255, 251, 230, 255 } });
}
static void TestLookupTable()
{
std::cout << "Test Lookup Table" << std::endl;
//build a color table with clamping off and verify that sampling works
vtkm::Range range{ 0.0, 50.0 };
vtkm::cont::ColorTable table(vtkm::cont::ColorTable::Preset::COOL_TO_WARM);
@ -545,17 +512,15 @@ public:
VTKM_TEST_ASSERT(ran, "color table failed to execute");
//values confirmed with ParaView 5.4
const vtkm::Vec3ui_8 correct_diverging_values[nvals] = { { 0, 0, 255 }, { 59, 76, 192 },
{ 122, 157, 248 }, { 191, 211, 246 },
{ 241, 204, 184 }, { 238, 134, 105 },
{ 180, 4, 38 }, { 255, 0, 0 } };
auto portal = colors.GetPortalConstControl();
for (std::size_t i = 0; i < nvals; ++i)
{
auto result = portal.Get(static_cast<vtkm::Id>(i));
VTKM_TEST_ASSERT(result == correct_diverging_values[i],
"incorrect value when interpolating between values");
}
CheckColors(colors,
{ { 0, 0, 255 },
{ 59, 76, 192 },
{ 122, 157, 248 },
{ 191, 211, 246 },
{ 241, 204, 184 },
{ 238, 134, 105 },
{ 180, 4, 38 },
{ 255, 0, 0 } });
}
struct TestAll

4
vtkm/cont/testing/TestingDataSetExplicit.h
View File

@ -44,7 +44,7 @@ private:
for (vtkm::Id i = 0; i < size; ++i)
{
if (ah.GetPortalConstControl().Get(i) != expected[i])
if (ah.ReadPortal().Get(i) != expected[i])
{
return false;
}
@ -125,7 +125,7 @@ private:
}
for (vtkm::IdComponent cellIndex = 0; cellIndex < numIncidentCells; cellIndex++)
{
vtkm::Id expectedCell = conn.GetPortalConstControl().Get(connectivityIndex + cellIndex);
vtkm::Id expectedCell = conn.ReadPortal().Get(connectivityIndex + cellIndex);
std::set<vtkm::Id>::iterator foundCell = correctIncidentCells.find(expectedCell);
VTKM_TEST_ASSERT(foundCell != correctIncidentCells.end(),
"An incident cell in the connectivity list is wrong or repeated.");

4
vtkm/cont/testing/TestingDataSetSingleType.h
View File

@ -47,7 +47,7 @@ private:
for (vtkm::Id i = 0; i < size; ++i)
{
if (ah.GetPortalConstControl().Get(i) != expected[i])
if (ah.ReadPortal().Get(i) != expected[i])
{
return false;
}
@ -130,7 +130,7 @@ private:
vtkm::Float32 expected[3] = { 20.1333f, 30.1667f, 40.2333f };
for (int i = 0; i < 3; ++i)
{
VTKM_TEST_ASSERT(test_equal(result.GetPortalConstControl().Get(i), expected[i]),
VTKM_TEST_ASSERT(test_equal(result.ReadPortal().Get(i), expected[i]),
"Wrong result for CellAverage worklet on explicit single type cellset data");
}
}

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

@ -542,7 +542,7 @@ private:
"Shrink did not set size of array handle correctly.");
// Get the array back and check its values.
auto checkPortal = handle.GetPortalConstControl();
auto checkPortal = handle.ReadPortal();
VTKM_TEST_ASSERT(checkPortal.GetNumberOfValues() == ARRAY_SIZE, "Storage portal wrong size.");
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
@ -621,7 +621,7 @@ private:
IdArrayHandle result;
result.Allocate(1);
result.GetPortalControl().Set(0, 0);
result.WritePortal().Set(0, 0);
TargetType target;
target.Value = 5;
@ -633,7 +633,7 @@ private:
vtkm::cont::Token token;
Algorithm::Schedule(VirtualObjectTransferKernel(base, result, token), 1);
}
VTKM_TEST_ASSERT(result.GetPortalConstControl().Get(0) == 5, "Did not get expected result");
VTKM_TEST_ASSERT(result.ReadPortal().Get(0) == 5, "Did not get expected result");
{
vtkm::cont::Token token;
@ -641,7 +641,7 @@ private:
base = static_cast<const BaseType*>(transfer.PrepareForExecution(true));
Algorithm::Schedule(VirtualObjectTransferKernel(base, result, token), 1);
}
VTKM_TEST_ASSERT(result.GetPortalConstControl().Get(0) == 10, "Did not get expected result");
VTKM_TEST_ASSERT(result.ReadPortal().Get(0) == 10, "Did not get expected result");
transfer.ReleaseResources();
}
@ -671,7 +671,7 @@ private:
std::cout << "Checking results." << std::endl;
for (vtkm::Id index = 0; index < 1; index++)
{
vtkm::Id value = handle.GetPortalConstControl().Get(index);
vtkm::Id value = handle.ReadPortal().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET,
"Got bad value for single value scheduled kernel.");
}
@ -702,7 +702,7 @@ private:
std::cout << "Checking results." << std::endl;
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
vtkm::Id value = handle.GetPortalConstControl().Get(index);
vtkm::Id value = handle.ReadPortal().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET, "Got bad value for scheduled kernels.");
}
} //release memory
@ -741,7 +741,7 @@ private:
for (vtkm::Id i = 0; i < numberOfSamples; ++i)
{
vtkm::Id randomIndex = distribution(generator);
vtkm::Id value = handle.GetPortalConstControl().Get(randomIndex);
vtkm::Id value = handle.ReadPortal().Get(randomIndex);
VTKM_TEST_ASSERT(value == randomIndex + OFFSET, "Got bad value for scheduled kernels.");
}
} //release memory
@ -776,7 +776,7 @@ private:
const vtkm::Id maxId = DIM_SIZE * DIM_SIZE * DIM_SIZE;
for (vtkm::Id index = 0; index < maxId; index++)
{
vtkm::Id value = handle.GetPortalConstControl().Get(index);
vtkm::Id value = handle.ReadPortal().Get(index);
VTKM_TEST_ASSERT(value == index + OFFSET, "Got bad value for scheduled vtkm::Id3 kernels.");
}
} //release memory
@ -814,7 +814,7 @@ private:
std::cout << "Checking results." << std::endl;
auto vPortal = valid.GetPortalConstControl();
auto vPortal = valid.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
{
bool isValid = vPortal.Get(i);
@ -860,7 +860,7 @@ private:
std::cout << "Checking results." << std::endl;
auto vPortal = valid.GetPortalConstControl();
auto vPortal = valid.ReadPortal();
for (vtkm::Id i = 0; i < numElems; i++)
{
bool isValid = vPortal.Get(i);
@ -896,7 +896,7 @@ private:
for (vtkm::Id index = 0; index < result.GetNumberOfValues(); index++)
{
const vtkm::Id value = result.GetPortalConstControl().Get(index);
const vtkm::Id value = result.ReadPortal().Get(index);
VTKM_TEST_ASSERT(value == (OFFSET + (index * 2) + 1), "Incorrect value in CopyIf result.");
}
@ -935,15 +935,15 @@ private:
// Check to make sure that temp was resized correctly during Unique.
// (This was a discovered bug at one point.)
temp.GetPortalConstControl(); // Forces copy back to control.
temp.ReadPortal(); // Forces copy back to control.
temp.ReleaseResourcesExecution(); // Make sure not counting on execution.
VTKM_TEST_ASSERT(temp.GetNumberOfValues() == 50,
"Unique did not resize array (or size did not copy to control).");
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id value = handle.GetPortalConstControl().Get(i);
vtkm::Id value1 = handle1.GetPortalConstControl().Get(i);
vtkm::Id value = handle.ReadPortal().Get(i);
vtkm::Id value1 = handle1.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == i % 50, "Got bad value (LowerBounds)");
VTKM_TEST_ASSERT(value1 >= i % 50, "Got bad value (UpperBounds)");
}
@ -980,8 +980,8 @@ private:
VTKM_TEST_ASSERT(handle.GetNumberOfValues() == RANDOMDATA_SIZE,
"LowerBounds returned incorrect size");
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(handle.GetPortalConstControl()),
vtkm::cont::ArrayPortalToIteratorEnd(handle.GetPortalConstControl()),
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(handle.ReadPortal()),
vtkm::cont::ArrayPortalToIteratorEnd(handle.ReadPortal()),
randomData);
VTKM_TEST_ASSERT(randomData[0] == 2, "Got bad value - LowerBounds");
VTKM_TEST_ASSERT(randomData[1] == 3, "Got bad value - LowerBounds");
@ -993,8 +993,8 @@ private:
VTKM_TEST_ASSERT(handle1.GetNumberOfValues() == RANDOMDATA_SIZE,
"UppererBounds returned incorrect size");
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(handle1.GetPortalConstControl()),
vtkm::cont::ArrayPortalToIteratorEnd(handle1.GetPortalConstControl()),
std::copy(vtkm::cont::ArrayPortalToIteratorBegin(handle1.ReadPortal()),
vtkm::cont::ArrayPortalToIteratorEnd(handle1.ReadPortal()),
randomData);
VTKM_TEST_ASSERT(randomData[0] == 3, "Got bad value - UpperBound");
VTKM_TEST_ASSERT(randomData[1] == 4, "Got bad value - UpperBound");
@ -1023,8 +1023,8 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE - 1; ++i)
{
vtkm::Id sorted1 = sorted.GetPortalConstControl().Get(i);
vtkm::Id sorted2 = sorted.GetPortalConstControl().Get(i + 1);
vtkm::Id sorted1 = sorted.ReadPortal().Get(i);
vtkm::Id sorted2 = sorted.ReadPortal().Get(i + 1);
VTKM_TEST_ASSERT(sorted1 <= sorted2, "Values not properly sorted.");
}
@ -1056,8 +1056,8 @@ private:
//Validate that sorted and comp_sorted are sorted in the opposite directions
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id sorted1 = sorted.GetPortalConstControl().Get(i);
vtkm::Id sorted2 = comp_sorted.GetPortalConstControl().Get(ARRAY_SIZE - (i + 1));
vtkm::Id sorted1 = sorted.ReadPortal().Get(i);
vtkm::Id sorted2 = comp_sorted.ReadPortal().Get(ARRAY_SIZE - (i + 1));
VTKM_TEST_ASSERT(sorted1 == sorted2, "Got bad sort values when using SortGreater");
}
@ -1065,8 +1065,8 @@ private:
Algorithm::Sort(comp_sorted, vtkm::SortLess());
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id sorted1 = sorted.GetPortalConstControl().Get(i);
vtkm::Id sorted2 = comp_sorted.GetPortalConstControl().Get(i);
vtkm::Id sorted1 = sorted.ReadPortal().Get(i);
vtkm::Id sorted2 = comp_sorted.ReadPortal().Get(i);
VTKM_TEST_ASSERT(sorted1 == sorted2, "Got bad sort values when using SortLess");
}
}
@ -1095,7 +1095,7 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Pair<vtkm::Id, vtkm::Id> kv_sorted = zipped.GetPortalConstControl().Get(i);
vtkm::Pair<vtkm::Id, vtkm::Id> kv_sorted = zipped.ReadPortal().Get(i);
VTKM_TEST_ASSERT((OFFSET + (i / (ARRAY_SIZE / 50))) == kv_sorted.first,
"ArrayZipHandle improperly sorted");
}
@ -1112,7 +1112,7 @@ private:
Algorithm::Sort(perm, vtkm::SortGreater());
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id sorted_value = perm.GetPortalConstControl().Get(i);
vtkm::Id sorted_value = perm.ReadPortal().Get(i);
VTKM_TEST_ASSERT((OFFSET + ((ARRAY_SIZE - (i + 1)) / (ARRAY_SIZE / 50))) == sorted_value,
"ArrayZipPermutation improperly sorted");
}
@ -1121,7 +1121,7 @@ private:
Algorithm::Sort(perm);
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id sorted_value = perm.GetPortalConstControl().Get(i);
vtkm::Id sorted_value = perm.ReadPortal().Get(i);
VTKM_TEST_ASSERT((OFFSET + (i / (ARRAY_SIZE / 50))) == sorted_value,
"ArrayZipPermutation improperly sorted");
}
@ -1154,8 +1154,8 @@ private:
{
//keys should be sorted from 1 to ARRAY_SIZE
//values should be sorted from (ARRAY_SIZE-1) to 0
Vec3 sorted_value = values.GetPortalConstControl().Get(i);
vtkm::Id sorted_key = keys.GetPortalConstControl().Get(i);
Vec3 sorted_value = values.ReadPortal().Get(i);
vtkm::Id sorted_key = keys.ReadPortal().Get(i);
VTKM_TEST_ASSERT((sorted_key == (i + 1)), "Got bad SortByKeys key");
VTKM_TEST_ASSERT(test_equal(sorted_value, TestValue(ARRAY_SIZE - 1 - i, Vec3())),
@ -1168,8 +1168,8 @@ private:
{
//keys should be sorted from ARRAY_SIZE to 1
//values should be sorted from 0 to (ARRAY_SIZE-1)
Vec3 sorted_value = values.GetPortalConstControl().Get(i);
vtkm::Id sorted_key = keys.GetPortalConstControl().Get(i);
Vec3 sorted_value = values.ReadPortal().Get(i);
vtkm::Id sorted_key = keys.ReadPortal().Get(i);
VTKM_TEST_ASSERT((sorted_key == (ARRAY_SIZE - i)), "Got bad SortByKeys key");
VTKM_TEST_ASSERT(test_equal(sorted_value, TestValue(i, Vec3())), "Got bad SortByKeys value");
@ -1181,8 +1181,8 @@ private:
{
//keys should be sorted from ARRAY_SIZE to 1
//values should be sorted from 0 to (ARRAY_SIZE-1)
Vec3 sorted_value = values.GetPortalConstControl().Get(i);
vtkm::Id sorted_key = keys.GetPortalConstControl().Get(i);
Vec3 sorted_value = values.ReadPortal().Get(i);
vtkm::Id sorted_key = keys.ReadPortal().Get(i);
VTKM_TEST_ASSERT((sorted_key == (ARRAY_SIZE - i)), "Got bad SortByKeys key");
VTKM_TEST_ASSERT(test_equal(sorted_value, TestValue(i, Vec3())), "Got bad SortByKeys value");
@ -1213,14 +1213,14 @@ private:
// Check to make sure that temp was resized correctly during Unique.
// (This was a discovered bug at one point.)
temp.GetPortalConstControl(); // Forces copy back to control.
temp.ReadPortal(); // Forces copy back to control.
temp.ReleaseResourcesExecution(); // Make sure not counting on execution.
VTKM_TEST_ASSERT(temp.GetNumberOfValues() == 50,
"Unique did not resize array (or size did not copy to control).");
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id value = handle.GetPortalConstControl().Get(i);
vtkm::Id value = handle.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == i % 50, "Got bad LowerBounds value with SortLess");
}
}
@ -1249,14 +1249,14 @@ private:
// Check to make sure that temp was resized correctly during Unique.
// (This was a discovered bug at one point.)
temp.GetPortalConstControl(); // Forces copy back to control.
temp.ReadPortal(); // Forces copy back to control.
temp.ReleaseResourcesExecution(); // Make sure not counting on execution.
VTKM_TEST_ASSERT(temp.GetNumberOfValues() == 50,
"Unique did not resize array (or size did not copy to control).");
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
vtkm::Id value = handle.GetPortalConstControl().Get(i);
vtkm::Id value = handle.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == (i % 50) + 1, "Got bad UpperBounds value with SortLess");
}
}
@ -1276,12 +1276,12 @@ private:
// Check to make sure that input was resized correctly during Unique.
// (This was a discovered bug at one point.)
input.GetPortalConstControl(); // Forces copy back to control.
input.ReadPortal(); // Forces copy back to control.
input.ReleaseResourcesExecution(); // Make sure not counting on execution.
VTKM_TEST_ASSERT(input.GetNumberOfValues() == 1,
"Unique did not resize array (or size did not copy to control).");
vtkm::Id value = input.GetPortalConstControl().Get(0);
vtkm::Id value = input.ReadPortal().Get(0);
VTKM_TEST_ASSERT(value == OFFSET, "Got bad unique value");
}
@ -1479,8 +1479,8 @@ private:
for (vtkm::Id i = 0; i < expectedLength; ++i)
{
const vtkm::Id k = keysOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id k = keysOut.ReadPortal().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedKeys[i] == k, "Incorrect reduced key");
VTKM_TEST_ASSERT(expectedValues[i] == v, "Incorrect reduced value");
}
@ -1517,8 +1517,8 @@ private:
for (vtkm::Id i = 0; i < expectedLength; ++i)
{
const vtkm::Id k = keysOut.GetPortalConstControl().Get(i);
const vtkm::Vec3f_64 v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id k = keysOut.ReadPortal().Get(i);
const vtkm::Vec3f_64 v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedKeys[i] == k, "Incorrect reduced key");
VTKM_TEST_ASSERT(expectedValues[i] == v, "Incorrect reduced vale");
}
@ -1573,8 +1573,8 @@ private:
for (vtkm::Id i = 0; i < expectedLength; ++i)
{
const vtkm::Id k = keysOut.GetPortalConstControl().Get(i);
const vtkm::Pair<ValueType, ValueType> v = valuesOutZip.GetPortalConstControl().Get(i);
const vtkm::Id k = keysOut.ReadPortal().Get(i);
const vtkm::Pair<ValueType, ValueType> v = valuesOutZip.ReadPortal().Get(i);
std::cout << "key=" << k << ","
<< "expectedValues1[i] = " << expectedValues1[i] << ","
<< "computed value1 = " << v.first << std::endl;
@ -1604,7 +1604,7 @@ private:
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(0);
const vtkm::Id v = valuesOut.ReadPortal().Get(0);
VTKM_TEST_ASSERT(5 == v, "Incorrect scanned value");
}
@ -1631,7 +1631,7 @@ private:
"Got wrong number of output values");
for (vtkm::Id i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
}
}
@ -1673,7 +1673,7 @@ private:
"Got wrong number of output values");
for (auto i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
}
}
@ -1699,7 +1699,7 @@ private:
"Got wrong number of output values");
for (auto i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
}
}
@ -1725,7 +1725,7 @@ private:
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(0);
const vtkm::Id v = valuesOut.ReadPortal().Get(0);
VTKM_TEST_ASSERT(init == v, "Incorrect scanned value");
}
@ -1753,7 +1753,7 @@ private:
"Got wrong number of output values");
for (auto i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[i] == v, "Incorrect scanned value");
}
}
@ -1796,7 +1796,7 @@ private:
"Got wrong number of output values");
for (vtkm::Id i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
}
}
@ -1825,7 +1825,7 @@ private:
"Got wrong number of output values");
for (vtkm::Id i = 0; i < expectedLength; i++)
{
const vtkm::Id v = valuesOut.GetPortalConstControl().Get(i);
const vtkm::Id v = valuesOut.ReadPortal().Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
}
}
@ -1853,7 +1853,7 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Id value = array.GetPortalConstControl().Get(i);
const vtkm::Id value = array.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == (i + 1) * OFFSET, "Incorrect partial sum");
}
@ -1861,7 +1861,7 @@ private:
array.Shrink(1);
sum = Algorithm::ScanInclusive(array, array);
VTKM_TEST_ASSERT(sum == OFFSET, "Incorrect partial sum");
const vtkm::Id value = array.GetPortalConstControl().Get(0);
const vtkm::Id value = array.ReadPortal().Get(0);
VTKM_TEST_ASSERT(value == OFFSET, "Incorrect partial sum");
std::cout << " size 0" << std::endl;
@ -1892,13 +1892,13 @@ private:
{
vtkm::Id index = static_cast<vtkm::Id>(i);
vtkm::Float64 expected = pow(1.01, static_cast<vtkm::Float64>(i + 1));
vtkm::Float64 got = array.GetPortalConstControl().Get(index);
vtkm::Float64 got = array.ReadPortal().Get(index);
VTKM_TEST_ASSERT(test_equal(got, expected), "Incorrect results for ScanInclusive");
}
for (std::size_t i = mid; i < ARRAY_SIZE; ++i)
{
vtkm::Id index = static_cast<vtkm::Id>(i);
VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(index) == 0.0f,
VTKM_TEST_ASSERT(array.ReadPortal().Get(index) == 0.0f,
"Incorrect results for ScanInclusive");
}
}
@ -1950,8 +1950,8 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Id input_value = array.GetPortalConstControl().Get(i);
const vtkm::Id result_value = result.GetPortalConstControl().Get(i);
const vtkm::Id input_value = array.ReadPortal().Get(i);
const vtkm::Id result_value = result.ReadPortal().Get(i);
VTKM_TEST_ASSERT(input_value == result_value, "Incorrect partial sum");
}
@ -1962,8 +1962,8 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Id input_value = array.GetPortalConstControl().Get(i);
const vtkm::Id result_value = result.GetPortalConstControl().Get(i);
const vtkm::Id input_value = array.ReadPortal().Get(i);
const vtkm::Id result_value = result.ReadPortal().Get(i);
VTKM_TEST_ASSERT(input_value == result_value, "Incorrect partial sum");
}
}
@ -1992,16 +1992,16 @@ private:
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Id value = array.GetPortalConstControl().Get(i);
const vtkm::Id value = array.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == i * OFFSET, "Incorrect partial sum");
}
std::cout << " size 1" << std::endl;
array.Shrink(1);
array.GetPortalControl().Set(0, OFFSET);
array.WritePortal().Set(0, OFFSET);
sum = Algorithm::ScanExclusive(array, array);
VTKM_TEST_ASSERT(sum == OFFSET, "Incorrect partial sum");
const vtkm::Id value = array.GetPortalConstControl().Get(0);
const vtkm::Id value = array.ReadPortal().Get(0);
VTKM_TEST_ASSERT(value == 0, "Incorrect partial sum");
std::cout << " size 0" << std::endl;
@ -2031,19 +2031,19 @@ private:
Algorithm::ScanExclusive(array, array, vtkm::Multiply(), initialValue);
VTKM_TEST_ASSERT(product == 0.0f, "ScanExclusive product result not 0.0");
VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(0) == initialValue,
VTKM_TEST_ASSERT(array.ReadPortal().Get(0) == initialValue,
"ScanExclusive result's first value != initialValue");
for (std::size_t i = 1; i <= mid; ++i)
{
vtkm::Id index = static_cast<vtkm::Id>(i);
vtkm::Float64 expected = pow(1.01, static_cast<vtkm::Float64>(i)) * initialValue;
vtkm::Float64 got = array.GetPortalConstControl().Get(index);
vtkm::Float64 got = array.ReadPortal().Get(index);
VTKM_TEST_ASSERT(test_equal(got, expected), "Incorrect results for ScanExclusive");
}
for (std::size_t i = mid + 1; i < ARRAY_SIZE; ++i)
{
vtkm::Id index = static_cast<vtkm::Id>(i);
VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(index) == 0.0f,
VTKM_TEST_ASSERT(array.ReadPortal().Get(index) == 0.0f,
"Incorrect results for ScanExclusive");
}
}
@ -2091,29 +2091,35 @@ private:
// let's validate that
Algorithm::ScanExtended(array, array);
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE + 1, "Output size incorrect.");
auto portal = array.GetPortalConstControl();
{
auto portal = array.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_SIZE + 1; ++i)
{
const vtkm::Id value = portal.Get(i);
VTKM_TEST_ASSERT(value == i * OFFSET, "Incorrect partial sum");
}
}
std::cout << " size 1" << std::endl;
array.Shrink(1);
array.GetPortalControl().Set(0, OFFSET);
array.WritePortal().Set(0, OFFSET);
Algorithm::ScanExtended(array, array);
VTKM_TEST_ASSERT(array.GetNumberOfValues() == 2);
portal = array.GetPortalConstControl();
{
auto portal = array.ReadPortal();
VTKM_TEST_ASSERT(portal.Get(0) == 0, "Incorrect initial value");
VTKM_TEST_ASSERT(portal.Get(1) == OFFSET, "Incorrect total sum");
}
std::cout << " size 0" << std::endl;
array.Shrink(0);
Algorithm::ScanExtended(array, array);
VTKM_TEST_ASSERT(array.GetNumberOfValues() == 1);
portal = array.GetPortalConstControl();
{
auto portal = array.ReadPortal();
VTKM_TEST_ASSERT(portal.Get(0) == 0, "Incorrect initial value");
}
}
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Extended Scan with multiplication operator" << std::endl;
@ -2136,7 +2142,7 @@ private:
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE + 1,
"ScanExtended output size incorrect.");
auto portal = array.GetPortalConstControl();
auto portal = array.ReadPortal();
VTKM_TEST_ASSERT(portal.Get(0) == initialValue,
"ScanExtended result's first value != initialValue");
@ -2303,7 +2309,7 @@ private:
Algorithm::Copy(input, temp);
VTKM_TEST_ASSERT(temp.GetNumberOfValues() == COPY_ARRAY_SIZE, "Copy Needs to Resize Array");
const auto& portal = temp.GetPortalConstControl();
const auto& portal = temp.ReadPortal();
std::uniform_int_distribution<vtkm::Id> distribution(0, COPY_ARRAY_SIZE - 1);
vtkm::Id numberOfSamples = COPY_ARRAY_SIZE / 50;
@ -2375,7 +2381,7 @@ private:
for (vtkm::Id i = 0; i < numberOfSamples; ++i)
{
vtkm::Id randomIndex = distribution(generator);
T value = output.GetPortalConstControl().Get(randomIndex);
T value = output.ReadPortal().Get(randomIndex);
VTKM_TEST_ASSERT(value == testData[static_cast<size_t>(randomIndex) + 100],
"Got bad value (CopySubRange 2)");
}
@ -2395,10 +2401,10 @@ private:
for (vtkm::Id i = 0; i < numberOfSamples; ++i)
{
vtkm::Id randomIndex = distribution(generator);
T value = output.GetPortalConstControl().Get(randomIndex);
T value = output.ReadPortal().Get(randomIndex);
VTKM_TEST_ASSERT(value == testData[static_cast<size_t>(randomIndex)],
"Got bad value (CopySubRange 5)");
value = output.GetPortalConstControl().Get(COPY_ARRAY_SIZE + randomIndex);
value = output.ReadPortal().Get(COPY_ARRAY_SIZE + randomIndex);
VTKM_TEST_ASSERT(value == testData[static_cast<size_t>(randomIndex)],
"Got bad value (CopySubRange 5)");
}
@ -2418,10 +2424,10 @@ private:
for (vtkm::Id i = 0; i < numberOfSamples; ++i)
{
vtkm::Id randomIndex = distribution(generator);
T value = output.GetPortalConstControl().Get(randomIndex);
T value = output.ReadPortal().Get(randomIndex);
VTKM_TEST_ASSERT(value == testData[static_cast<size_t>(randomIndex)],
"Got bad value (CopySubRange 6)");
value = output.GetPortalConstControl().Get(COPY_ARRAY_SIZE + randomIndex);
value = output.ReadPortal().Get(COPY_ARRAY_SIZE + randomIndex);
VTKM_TEST_ASSERT(value == testData[static_cast<size_t>(randomIndex)],
"Got bad value (CopySubRange 6)");
}
@ -2510,7 +2516,7 @@ private:
std::vector<vtkm::Id>::const_iterator c = testData.begin();
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i, ++c)
{
vtkm::Float64 value = temp.GetPortalConstControl().Get(i);
vtkm::Float64 value = temp.ReadPortal().Get(i);
VTKM_TEST_ASSERT(value == static_cast<vtkm::Float64>(*c), "Got bad value (Copy)");
}
}
@ -2541,7 +2547,7 @@ private:
Algorithm::Schedule(AtomicKernel<vtkm::Int32>(atomic, token), SHORT_ARRAY_SIZE);
}
vtkm::Int32 expected = vtkm::Int32(atomicCount);
vtkm::Int32 actual = atomicElement.GetPortalControl().Get(0);
vtkm::Int32 actual = atomicElement.WritePortal().Get(0);
VTKM_TEST_ASSERT(expected == actual, "Did not get expected value: Atomic add Int32");
}
@ -2558,7 +2564,7 @@ private:
Algorithm::Schedule(AtomicKernel<vtkm::Int64>(atomic, token), SHORT_ARRAY_SIZE);
}
vtkm::Int64 expected = vtkm::Int64(atomicCount);
vtkm::Int64 actual = atomicElement.GetPortalControl().Get(0);
vtkm::Int64 actual = atomicElement.WritePortal().Get(0);
VTKM_TEST_ASSERT(expected == actual, "Did not get expected value: Atomic add Int64");
}
@ -2575,7 +2581,7 @@ private:
Algorithm::Schedule(AtomicCASKernel<vtkm::Int32>(atomic, token), SHORT_ARRAY_SIZE);
}
vtkm::Int32 expected = vtkm::Int32(atomicCount);
vtkm::Int32 actual = atomicElement.GetPortalControl().Get(0);
vtkm::Int32 actual = atomicElement.WritePortal().Get(0);
VTKM_TEST_ASSERT(expected == actual, "Did not get expected value: Atomic CAS Int32");
}
@ -2592,7 +2598,7 @@ private:
Algorithm::Schedule(AtomicCASKernel<vtkm::Int64>(atomic, token), SHORT_ARRAY_SIZE);
}
vtkm::Int64 expected = vtkm::Int64(atomicCount);
vtkm::Int64 actual = atomicElement.GetPortalControl().Get(0);
vtkm::Int64 actual = atomicElement.WritePortal().Get(0);
VTKM_TEST_ASSERT(expected == actual, "Did not get expected value: Atomic CAS Int64");
}
}
@ -2614,8 +2620,8 @@ private:
Algorithm::BitFieldToUnorderedSet(bits, indices);
Algorithm::Sort(indices);
auto bitPortal = bits.GetPortalConstControl();
auto indexPortal = indices.GetPortalConstControl();
auto bitPortal = bits.ReadPortal();
auto indexPortal = indices.ReadPortal();
const vtkm::Id numIndices = indices.GetNumberOfValues();
vtkm::Id curIndex = 0;
@ -2648,7 +2654,7 @@ private:
BitField bits;
{
bits.Allocate(NumBits);
auto fillPortal = bits.GetPortalControl();
auto fillPortal = bits.WritePortal();
for (vtkm::Id i = 0; i < NumWords; ++i)
{
fillPortal.SetWord(i, mask);
@ -2668,7 +2674,7 @@ private:
BitField bits;
{
bits.Allocate(NumBits);
auto fillPortal = bits.GetPortalControl();
auto fillPortal = bits.WritePortal();
for (vtkm::Id i = 0; i < NumWords; ++i)
{
fillPortal.SetWord(i, static_cast<WordType>(rng(mt)));
@ -2694,10 +2700,11 @@ private:
{
BitField bits;
Algorithm::Fill(bits, false, 32 * 32);
auto portal = bits.GetPortalControl();
auto portal = bits.WritePortal();
portal.SetWord(2, 0x00100000ul);
portal.SetWord(8, 0x00100010ul);
portal.SetWord(11, 0x10000000ul);
portal.Detach();
testIndexArray(bits);
}
}
@ -2716,7 +2723,7 @@ private:
auto verifyPopCount = [](const BitField& bits) {
vtkm::Id refPopCount = 0;
const vtkm::Id numBits = bits.GetNumberOfBits();
auto portal = bits.GetPortalConstControl();
auto portal = bits.ReadPortal();
for (vtkm::Id idx = 0; idx < numBits; ++idx)
{
if (portal.GetBit(idx))
@ -2738,7 +2745,7 @@ private:
BitField bits;
{
bits.Allocate(NumBits);
auto fillPortal = bits.GetPortalControl();
auto fillPortal = bits.WritePortal();
for (vtkm::Id i = 0; i < NumWords; ++i)
{
fillPortal.SetWord(i, mask);
@ -2758,7 +2765,7 @@ private:
BitField bits;
{
bits.Allocate(NumBits);
auto fillPortal = bits.GetPortalControl();
auto fillPortal = bits.WritePortal();
for (vtkm::Id i = 0; i < NumWords; ++i)
{
fillPortal.SetWord(i, static_cast<WordType>(rng(mt)));
@ -2784,10 +2791,11 @@ private:
{
BitField bits;
Algorithm::Fill(bits, false, 32 * 32);
auto portal = bits.GetPortalControl();
auto portal = bits.WritePortal();
portal.SetWord(2, 0x00100000ul);
portal.SetWord(8, 0x00100010ul);
portal.SetWord(11, 0x10000000ul);
portal.Detach();
verifyPopCount(bits);
}
}
@ -2814,7 +2822,7 @@ private:
vtkm::Id numWords = bits.GetNumberOfWords<WordType>();
VTKM_TEST_ASSERT(numWords == NumWords, "Unexpected number of words.");
auto portal = bits.GetPortalConstControl();
auto portal = bits.ReadPortal();
for (vtkm::Id wordIdx = 0; wordIdx < NumWords; ++wordIdx)
{
VTKM_TEST_ASSERT(portal.GetWord<WordType>(wordIdx) == mask,
@ -2842,7 +2850,7 @@ private:
vtkm::Id numWords = bits.GetNumberOfWords<WordType>();
VTKM_TEST_ASSERT(numWords == NumWords, "Unexpected number of words.");
auto portal = bits.GetPortalConstControl();
auto portal = bits.ReadPortal();
for (vtkm::Id wordIdx = 0; wordIdx < NumWords; ++wordIdx)
{
VTKM_TEST_ASSERT(portal.GetWord<WordType>(wordIdx) == invWord,
@ -2875,7 +2883,7 @@ private:
vtkm::Id numBits = bits.GetNumberOfBits();
VTKM_TEST_ASSERT(numBits == NumBits, "Unexpected number of bits.");
auto portal = bits.GetPortalConstControl();
auto portal = bits.ReadPortal();
for (vtkm::Id bitIdx = 0; bitIdx < NumBits; ++bitIdx)
{
VTKM_TEST_ASSERT(portal.GetBit(bitIdx) == value, "Incorrect bit in result BitField.");
@ -2890,7 +2898,7 @@ private:
vtkm::Id numBits = bits.GetNumberOfBits();
VTKM_TEST_ASSERT(numBits == NumBits, "Unexpected number of bits.");
auto portal = bits.GetPortalConstControl();
auto portal = bits.ReadPortal();
for (vtkm::Id bitIdx = 0; bitIdx < NumBits; ++bitIdx)
{
VTKM_TEST_ASSERT(portal.GetBit(bitIdx) == !value, "Incorrect bit in result BitField.");
@ -2926,7 +2934,7 @@ private:
Algorithm::Fill(handle, 867, ARRAY_SIZE);
{
auto portal = handle.GetPortalConstControl();
auto portal = handle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE);
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
@ -2936,7 +2944,7 @@ private:
Algorithm::Fill(handle, 5309);
{
auto portal = handle.GetPortalConstControl();
auto portal = handle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE);
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{

177
vtkm/cont/testing/TestingFancyArrayHandles.h
View File

@ -256,7 +256,7 @@ private:
using ValueType = vtkm::Vec<ComponentType, NUM_COMPONENTS>;
using ComponentArrayType = vtkm::cont::ArrayHandle<ComponentType>;
using SOAPortalType =
vtkm::internal::ArrayPortalSOA<ValueType, typename ComponentArrayType::PortalControl>;
vtkm::internal::ArrayPortalSOA<ValueType, typename ComponentArrayType::WritePortalType>;
std::cout << "Test SOA portal reflects data in component portals." << std::endl;
SOAPortalType soaPortalIn(ARRAY_SIZE);
@ -266,7 +266,7 @@ private:
{
vtkm::cont::ArrayHandle<ComponentType> array;
array.Allocate(ARRAY_SIZE);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
for (vtkm::IdComponent valueIndex = 0; valueIndex < ARRAY_SIZE; ++valueIndex)
{
portal.Set(valueIndex, TestValue(valueIndex, ValueType{})[componentIndex]);
@ -281,22 +281,25 @@ private:
CheckPortal(soaPortalIn);
std::cout << "Test data set in SOA portal gets set in component portals." << std::endl;
{
SOAPortalType soaPortalOut(ARRAY_SIZE);
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS; ++componentIndex)
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS;
++componentIndex)
{
vtkm::cont::ArrayHandle<ComponentType> array;
array.Allocate(ARRAY_SIZE);
auto portal = array.GetPortalControl();
auto portal = array.WritePortal();
soaPortalOut.SetPortal(componentIndex, portal);
implArrays[static_cast<std::size_t>(componentIndex)] = array;
}
SetPortal(soaPortalOut);
}
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS; ++componentIndex)
{
auto portal = implArrays[static_cast<size_t>(componentIndex)].GetPortalConstControl();
auto portal = implArrays[static_cast<size_t>(componentIndex)].ReadPortal();
for (vtkm::Id valueIndex = 0; valueIndex < ARRAY_SIZE; ++valueIndex)
{
ComponentType x = TestValue(valueIndex, ValueType{})[componentIndex];
@ -322,7 +325,7 @@ private:
{
vtkm::cont::ArrayHandle<ComponentType> componentArray;
componentArray.Allocate(ARRAY_SIZE);
auto componentPortal = componentArray.GetPortalControl();
auto componentPortal = componentArray.WritePortal();
for (vtkm::Id valueIndex = 0; valueIndex < ARRAY_SIZE; ++valueIndex)
{
componentPortal.Set(
@ -333,13 +336,13 @@ private:
}
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(soaArray.GetPortalConstControl().GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
VTKM_TEST_ASSERT(soaArray.ReadPortal().GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.ReadPortal());
vtkm::cont::ArrayHandle<ValueType> basicArray;
vtkm::cont::ArrayCopy(soaArray, basicArray);
VTKM_TEST_ASSERT(basicArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(basicArray.GetPortalConstControl());
CheckPortal(basicArray.ReadPortal());
}
{
@ -359,35 +362,35 @@ private:
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray = { vector0, vector1, vector2 };
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
CheckPortal(soaArray.ReadPortal());
}
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray =
vtkm::cont::make_ArrayHandleSOA<Vec3>({ vector0, vector1, vector2 });
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
CheckPortal(soaArray.ReadPortal());
}
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray =
vtkm::cont::make_ArrayHandleSOA(vector0, vector1, vector2);
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
CheckPortal(soaArray.ReadPortal());
}
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray = vtkm::cont::make_ArrayHandleSOA<Vec3>(
{ &vector0.front(), &vector1.front(), &vector2.front() }, ARRAY_SIZE);
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
CheckPortal(soaArray.ReadPortal());
}
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray = vtkm::cont::make_ArrayHandleSOA(
ARRAY_SIZE, &vector0.front(), &vector1.front(), &vector2.front());
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.GetPortalConstControl());
CheckPortal(soaArray.ReadPortal());
}
}
}
@ -404,7 +407,7 @@ private:
vtkm::cont::ArrayHandle<ValueType> basicArray;
basicArray.Allocate(ARRAY_SIZE);
SetPortal(basicArray.GetPortalControl());
SetPortal(basicArray.WritePortal());
vtkm::cont::ArrayHandleSOA<ValueType> soaArray;
vtkm::cont::ArrayCopy(basicArray, soaArray);
@ -413,7 +416,7 @@ private:
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS; ++componentIndex)
{
vtkm::cont::ArrayHandle<ComponentType> componentArray = soaArray.GetArray(componentIndex);
auto componentPortal = componentArray.GetPortalConstControl();
auto componentPortal = componentArray.ReadPortal();
for (vtkm::Id valueIndex = 0; valueIndex < ARRAY_SIZE; ++valueIndex)
{
ComponentType expected =
@ -449,11 +452,11 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const vtkm::Vec<ValueType, 3> result_v = result.GetPortalConstControl().Get(i);
const vtkm::Vec<ValueType, 3> result_v = result.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, vtkm::Vec<ValueType, 3>(value)),
"CompositeVector Handle Failed");
const vtkm::Vec<ValueType, 3> result_c = composite.GetPortalConstControl().Get(i);
const vtkm::Vec<ValueType, 3> result_c = composite.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_c, vtkm::Vec<ValueType, 3>(value)),
"CompositeVector Handle Failed");
}
@ -480,8 +483,8 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType control_value = constant.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
const ValueType control_value = constant.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, value), "Counting Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Counting Handle Control Failed");
}
@ -515,9 +518,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
const ValueType correct_value = ValueType(component_value);
const ValueType control_value = counting.GetPortalConstControl().Get(i);
const ValueType control_value = counting.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Counting Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Counting Handle Control Failed");
component_value = ComponentType(component_value + ComponentType(1));
@ -548,9 +551,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
const ValueType correct_value = functor(i);
const ValueType control_value = implicit.GetPortalConstControl().Get(i);
const ValueType control_value = implicit.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Implicit Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Implicit Handle Failed");
}
@ -601,13 +604,13 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
ValueType correct_value;
if (i < implicitLen)
correct_value = implicit.GetPortalConstControl().Get(i);
correct_value = implicit.ReadPortal().Get(i);
else
correct_value = basic.GetPortalConstControl().Get(i - implicitLen);
const ValueType control_value = concatenate.GetPortalConstControl().Get(i);
correct_value = basic.ReadPortal().Get(i - implicitLen);
const ValueType control_value = concatenate.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value),
"ArrayHandleConcatenate as Input Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value),
@ -658,9 +661,9 @@ private:
const vtkm::Id value_index = i;
const vtkm::Id key_index = start_pos + i;
const ValueType result_v = result.GetPortalConstControl().Get(value_index);
const ValueType correct_value = implicit.GetPortalConstControl().Get(key_index);
const ValueType control_value = permutation.GetPortalConstControl().Get(value_index);
const ValueType result_v = result.ReadPortal().Get(value_index);
const ValueType correct_value = implicit.ReadPortal().Get(key_index);
const ValueType control_value = permutation.ReadPortal().Get(value_index);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Implicit Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Implicit Handle Failed");
}
@ -704,9 +707,9 @@ private:
const vtkm::Id value_index = i;
const vtkm::Id key_index = start_pos + i;
const ValueType result_v = result.GetPortalConstControl().Get(value_index);
const ValueType correct_value = implicit.GetPortalConstControl().Get(key_index);
const ValueType control_value = view.GetPortalConstControl().Get(value_index);
const ValueType result_v = result.ReadPortal().Get(value_index);
const ValueType correct_value = implicit.ReadPortal().Get(key_index);
const ValueType control_value = view.ReadPortal().Get(value_index);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Implicit Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Implicit Handle Failed");
}
@ -729,7 +732,7 @@ private:
transformed = vtkm::cont::make_ArrayHandleTransform(input, functor);
input.Allocate(length);
SetPortal(input.GetPortalControl());
SetPortal(input.WritePortal());
vtkm::cont::printSummary_ArrayHandle(transformed, std::cout);
std::cout << std::endl;
@ -742,9 +745,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
const ValueType correct_value = functor(TestValue(i, ValueType()));
const ValueType control_value = transformed.GetPortalConstControl().Get(i);
const ValueType control_value = transformed.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Transform Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Transform Handle Control Failed");
}
@ -767,7 +770,7 @@ private:
auto transformed = vtkm::cont::make_ArrayHandleTransform(input, virtualFunctor);
input.Allocate(length);
SetPortal(input.GetPortalControl());
SetPortal(input.WritePortal());
vtkm::cont::printSummary_ArrayHandle(transformed, std::cout);
std::cout << std::endl;
@ -780,9 +783,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = result.GetPortalConstControl().Get(i);
const ValueType result_v = result.ReadPortal().Get(i);
const ValueType correct_value = functor(TestValue(i, ValueType()));
const ValueType control_value = transformed.GetPortalConstControl().Get(i);
const ValueType control_value = transformed.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Transform Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value), "Transform Handle Control Failed");
}
@ -822,9 +825,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const OutputValueType result_v = result.GetPortalConstControl().Get(i);
const OutputValueType result_v = result.ReadPortal().Get(i);
const OutputValueType correct_value = functor(ValueType(component_value));
const OutputValueType control_value = countingTransformed.GetPortalConstControl().Get(i);
const OutputValueType control_value = countingTransformed.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Transform Counting Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value),
"Transform Counting Handle Control Failed");
@ -855,8 +858,8 @@ private:
vtkm::Id length = ARRAY_SIZE;
for (vtkm::Id i = 0; i < length; ++i)
{
VTKM_TEST_ASSERT(result.GetPortalConstControl().Get(i) ==
static_cast<CastToType>(input.GetPortalConstControl().Get(i)),
VTKM_TEST_ASSERT(result.ReadPortal().Get(i) ==
static_cast<CastToType>(input.ReadPortal().Get(i)),
"Casting ArrayHandle Failed");
}
}
@ -886,8 +889,8 @@ private:
vtkm::Id length = ARRAY_SIZE;
for (vtkm::Id i = 0; i < length; ++i)
{
VTKM_TEST_ASSERT(input.GetPortalConstControl().Get(i) ==
static_cast<vtkm::Id>(result.GetPortalConstControl().Get(i)),
VTKM_TEST_ASSERT(input.ReadPortal().Get(i) ==
static_cast<vtkm::Id>(result.ReadPortal().Get(i)),
"Casting ArrayHandle Failed");
}
}
@ -916,8 +919,7 @@ private:
std::cout << std::endl;
// verify results
VTKM_TEST_ASSERT(
test_equal_portals(result.GetPortalConstControl(), input.GetPortalConstControl()),
VTKM_TEST_ASSERT(test_equal_portals(result.ReadPortal(), input.ReadPortal()),
"CastingArrayHandle failed");
}
};
@ -945,8 +947,7 @@ private:
std::cout << std::endl;
// verify results
VTKM_TEST_ASSERT(
test_equal_portals(input.GetPortalConstControl(), result.GetPortalConstControl()),
VTKM_TEST_ASSERT(test_equal_portals(input.ReadPortal(), result.ReadPortal()),
"Multiplexing ArrayHandle failed");
}
};
@ -987,7 +988,7 @@ private:
vtkm::Id totalIndex = 0;
for (vtkm::Id index = 0; index < ARRAY_SIZE; ++index)
{
const ValueType result = resultArray.GetPortalConstControl().Get(index);
const ValueType result = resultArray.ReadPortal().Get(index);
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS;
componentIndex++)
{
@ -1010,7 +1011,7 @@ private:
vtkm::cont::ArrayHandle<ValueType> baseArray;
baseArray.Allocate(ARRAY_SIZE);
SetPortal(baseArray.GetPortalControl());
SetPortal(baseArray.WritePortal());
vtkm::cont::ArrayHandle<ComponentType> resultArray;
@ -1039,7 +1040,7 @@ private:
for (vtkm::IdComponent componentIndex = 0; componentIndex < NUM_COMPONENTS;
componentIndex++)
{
const ComponentType result = resultArray.GetPortalConstControl().Get(totalIndex);
const ComponentType result = resultArray.ReadPortal().Get(totalIndex);
VTKM_TEST_ASSERT(test_equal(result, expectedValue[componentIndex]),
"Result array got wrong value.");
totalIndex++;
@ -1093,7 +1094,7 @@ private:
vtkm::cont::ArrayHandle<ComponentType> sourceArray;
sourceArray.Allocate(sourceArraySize);
SetPortal(sourceArray.GetPortalControl());
SetPortal(sourceArray.WritePortal());
vtkm::cont::printSummary_ArrayHandle(
vtkm::cont::make_ArrayHandleGroupVecVariable(sourceArray, offsetsArray), std::cout);
@ -1105,7 +1106,7 @@ private:
dispatcher.Invoke(vtkm::cont::make_ArrayHandleGroupVecVariable(sourceArray, offsetsArray),
dummyArray);
dummyArray.GetPortalConstControl();
dummyArray.ReadPortal();
}
};
@ -1160,7 +1161,7 @@ private:
vtkm::cont::printSummary_ArrayHandle(sourceArray, std::cout);
std::cout << std::endl;
CheckPortal(sourceArray.GetPortalConstControl());
CheckPortal(sourceArray.ReadPortal());
}
};
@ -1200,7 +1201,7 @@ private:
//verify that the control portal works
for (int i = 0; i < ARRAY_SIZE; ++i)
{
const PairType result_v = result.GetPortalConstControl().Get(i);
const PairType result_v = result.ReadPortal().Get(i);
const PairType correct_value(KeyType(static_cast<KeyComponentType>(ARRAY_SIZE - i)),
ValueType(static_cast<ValueComponentType>(i)));
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "ArrayHandleZip Failed as input");
@ -1214,19 +1215,11 @@ private:
VTKM_CONT void operator()(const ValueType vtkmNotUsed(v)) const
{
using DiscardHandleType = vtkm::cont::ArrayHandleDiscard<ValueType>;
using ComponentType = typename vtkm::VecTraits<ValueType>::ComponentType;
using Portal = typename vtkm::cont::ArrayHandle<ValueType>::PortalControl;
const vtkm::Id length = ARRAY_SIZE;
vtkm::cont::ArrayHandle<ValueType> input;
input.Allocate(length);
Portal inputPortal = input.GetPortalControl();
for (vtkm::Id i = 0; i < length; ++i)
{
inputPortal.Set(i, ValueType(ComponentType(i)));
}
SetPortal(input.WritePortal());
DiscardHandleType discard;
discard.Allocate(length);
@ -1251,15 +1244,9 @@ private:
using PermutationHandleType =
vtkm::cont::ArrayHandlePermutation<KeyHandleType, ValueHandleType>;
using ComponentType = typename vtkm::VecTraits<ValueType>::ComponentType;
vtkm::cont::ArrayHandle<ValueType> input;
using Portal = typename vtkm::cont::ArrayHandle<ValueType>::PortalControl;
input.Allocate(length);
Portal inputPortal = input.GetPortalControl();
for (vtkm::Id i = 0; i < length; ++i)
{
inputPortal.Set(i, ValueType(ComponentType(i)));
}
SetPortal(input.WritePortal());
ValueHandleType values;
values.Allocate(length * 2);
@ -1274,13 +1261,7 @@ private:
std::cout << std::endl;
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = permutation.GetPortalConstControl().Get(i);
const ValueType correct_value = ValueType(ComponentType(i));
VTKM_TEST_ASSERT(test_equal(result_v, correct_value),
"Permutation Handle Failed As Output");
}
CheckPortal(permutation.ReadPortal());
}
};
@ -1294,15 +1275,9 @@ private:
using ValueHandleType = vtkm::cont::ArrayHandle<ValueType>;
using ViewHandleType = vtkm::cont::ArrayHandleView<ValueHandleType>;
using ComponentType = typename vtkm::VecTraits<ValueType>::ComponentType;
vtkm::cont::ArrayHandle<ValueType> input;
using Portal = typename vtkm::cont::ArrayHandle<ValueType>::PortalControl;
input.Allocate(length);
Portal inputPortal = input.GetPortalControl();
for (vtkm::Id i = 0; i < length; ++i)
{
inputPortal.Set(i, ValueType(ComponentType(i)));
}
SetPortal(input.WritePortal());
ValueHandleType values;
values.Allocate(length * 2);
@ -1315,13 +1290,7 @@ private:
std::cout << std::endl;
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = view.GetPortalConstControl().Get(i);
const ValueType correct_value = ValueType(ComponentType(i));
VTKM_TEST_ASSERT(test_equal(result_v, correct_value),
"Permutation Handle Failed As Output");
}
CheckPortal(view.ReadPortal());
}
};
@ -1339,7 +1308,7 @@ private:
vtkm::cont::ArrayHandle<ValueType> input;
input.Allocate(length);
SetPortal(input.GetPortalControl());
SetPortal(input.WritePortal());
vtkm::cont::ArrayHandle<ValueType> output;
auto transformed = vtkm::cont::make_ArrayHandleTransform(output, functor, inverseFunctor);
@ -1353,9 +1322,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = output.GetPortalConstControl().Get(i);
const ValueType result_v = output.ReadPortal().Get(i);
const ValueType correct_value = inverseFunctor(TestValue(i, ValueType()));
const ValueType control_value = transformed.GetPortalConstControl().Get(i);
const ValueType control_value = transformed.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Transform Handle Failed");
VTKM_TEST_ASSERT(test_equal(functor(result_v), control_value),
"Transform Handle Control Failed");
@ -1382,7 +1351,7 @@ private:
vtkm::cont::ArrayHandle<ValueType> input;
input.Allocate(length);
SetPortal(input.GetPortalControl());
SetPortal(input.WritePortal());
vtkm::cont::ArrayHandle<ValueType> output;
auto transformed =
@ -1397,9 +1366,9 @@ private:
//verify that the control portal works
for (vtkm::Id i = 0; i < length; ++i)
{
const ValueType result_v = output.GetPortalConstControl().Get(i);
const ValueType result_v = output.ReadPortal().Get(i);
const ValueType correct_value = inverseFunctor(TestValue(i, ValueType()));
const ValueType control_value = transformed.GetPortalConstControl().Get(i);
const ValueType control_value = transformed.ReadPortal().Get(i);
VTKM_TEST_ASSERT(test_equal(result_v, correct_value), "Transform Handle Failed");
VTKM_TEST_ASSERT(test_equal(functor(result_v), control_value),
"Transform Handle Control Failed");
@ -1440,8 +1409,8 @@ private:
//now the two arrays we have zipped should have data inside them
for (int i = 0; i < ARRAY_SIZE; ++i)
{
const KeyType result_key = result_keys.GetPortalConstControl().Get(i);
const ValueType result_value = result_values.GetPortalConstControl().Get(i);
const KeyType result_key = result_keys.ReadPortal().Get(i);
const ValueType result_value = result_values.ReadPortal().Get(i);
VTKM_TEST_ASSERT(
test_equal(result_key, KeyType(static_cast<KeyComponentType>(ARRAY_SIZE - i))),
@ -1459,7 +1428,7 @@ private:
{
vtkm::cont::ArrayHandle<ValueType> inputValues;
inputValues.Allocate(ARRAY_SIZE);
SetPortal(inputValues.GetPortalControl());
SetPortal(inputValues.WritePortal());
vtkm::cont::ArrayHandle<ValueType> outputValues;
outputValues.Allocate(ARRAY_SIZE);
@ -1470,7 +1439,7 @@ private:
vtkm::cont::printSummary_ArrayHandle(outputValues, std::cout);
std::cout << std::endl;
CheckPortal(outputValues.GetPortalConstControl());
CheckPortal(outputValues.ReadPortal());
}
};

2
vtkm/cont/testing/TestingImplicitFunction.h
View File

@ -77,7 +77,7 @@ bool TestArrayEqual(const vtkm::cont::ArrayHandle<ItemType>& result,
const std::array<ItemType, N>& expected)
{
bool success = false;
auto portal = result.GetPortalConstControl();
auto portal = result.ReadPortal();
vtkm::Id count = portal.GetNumberOfValues();
if (static_cast<std::size_t>(count) == N)

8
vtkm/cont/testing/TestingPointLocatorUniformGrid.h
View File

@ -170,10 +170,10 @@ public:
bool passTest = true;
for (vtkm::Int32 i = 0; i < nTestingPoint; i++)
{
vtkm::Id workletIdx = nnId_Handle.GetPortalControl().Get(i);
vtkm::FloatDefault workletDis = nnDis_Handle.GetPortalConstControl().Get(i);
vtkm::Id bfworkletIdx = bfnnId_Handle.GetPortalControl().Get(i);
vtkm::FloatDefault bfworkletDis = bfnnDis_Handle.GetPortalConstControl().Get(i);
vtkm::Id workletIdx = nnId_Handle.WritePortal().Get(i);
vtkm::FloatDefault workletDis = nnDis_Handle.ReadPortal().Get(i);
vtkm::Id bfworkletIdx = bfnnId_Handle.WritePortal().Get(i);
vtkm::FloatDefault bfworkletDis = bfnnDis_Handle.ReadPortal().Get(i);
if (workletIdx != bfworkletIdx)
{

2
vtkm/cont/testing/TestingSerialization.h
View File

@ -125,7 +125,7 @@ struct RandomArrayHandle
for (vtkm::Id i = 0; i < length; ++i)
{
a.GetPortalControl().Set(i, RandomValue<T>::Make(rangen));
a.WritePortal().Set(i, RandomValue<T>::Make(rangen));
}
return a;

21
vtkm/cont/testing/TestingVirtualObjectHandle.h
View File

@ -118,10 +118,13 @@ private:
FloatArrayHandle output;
Algorithm::Copy(transformed, output);
auto portal = output.GetPortalConstControl();
auto portal = output.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_LEN; ++i)
{
VTKM_TEST_ASSERT(test_equal(portal.Get(i), i * i), "\tIncorrect result");
vtkm::FloatDefault expected = TestValue(i, vtkm::FloatDefault{});
expected = expected * expected;
VTKM_TEST_ASSERT(
test_equal(portal.Get(i), expected), "Expected ", expected, " but got ", portal.Get(i));
}
std::cout << "\tSuccess." << std::endl;
@ -167,11 +170,13 @@ private:
FloatArrayHandle output;
Algorithm::Copy(transformed, output);
auto portal = output.GetPortalConstControl();
auto portal = output.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_LEN; ++i)
{
VTKM_TEST_ASSERT(test_equal(portal.Get(i), i * this->Mul->GetMultiplicand()),
"\tIncorrect result");
vtkm::FloatDefault expected =
TestValue(i, vtkm::FloatDefault{}) * this->Mul->GetMultiplicand();
VTKM_TEST_ASSERT(
test_equal(portal.Get(i), expected), "Expected ", expected, " but got ", portal.Get(i));
}
std::cout << "\tSuccess." << std::endl;
@ -194,11 +199,7 @@ public:
{
vtkm::cont::ArrayHandle<vtkm::FloatDefault> input;
input.Allocate(ARRAY_LEN);
auto portal = input.GetPortalControl();
for (vtkm::Id i = 0; i < ARRAY_LEN; ++i)
{
portal.Set(i, vtkm::FloatDefault(i));
}
SetPortal(input.WritePortal());
TransformerHandle handle;

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

@ -43,7 +43,7 @@ void TryCopy()
vtkm::cont::ArrayHandleIndex input(ARRAY_SIZE);
vtkm::cont::ArrayHandle<ValueType> output;
vtkm::cont::ArrayCopy(input, output);
TestValues(input.GetPortalConstControl(), output.GetPortalConstControl());
TestValues(input.ReadPortal(), output.ReadPortal());
}
{ // basic -> basic
@ -52,21 +52,21 @@ void TryCopy()
vtkm::cont::ArrayCopy(source, input);
vtkm::cont::ArrayHandle<ValueType> output;
vtkm::cont::ArrayCopy(input, output);
TestValues(input.GetPortalConstControl(), output.GetPortalConstControl());
TestValues(input.ReadPortal(), output.ReadPortal());
}
{ // implicit -> implicit (index)
vtkm::cont::ArrayHandleIndex input(ARRAY_SIZE);
vtkm::cont::ArrayHandleIndex output;
vtkm::cont::ArrayCopy(input, output);
TestValues(input.GetPortalConstControl(), output.GetPortalConstControl());
TestValues(input.ReadPortal(), output.ReadPortal());
}
{ // implicit -> implicit (constant)
vtkm::cont::ArrayHandleConstant<int> input(41, ARRAY_SIZE);
vtkm::cont::ArrayHandleConstant<int> output;
vtkm::cont::ArrayCopy(input, output);
TestValues(input.GetPortalConstControl(), output.GetPortalConstControl());
TestValues(input.ReadPortal(), output.ReadPortal());
}
{ // implicit -> implicit (base->derived, constant)
@ -74,7 +74,7 @@ void TryCopy()
vtkm::cont::make_ArrayHandleConstant<int>(41, ARRAY_SIZE);
vtkm::cont::ArrayHandleConstant<int> output;
vtkm::cont::ArrayCopy(input, output);
TestValues(input.GetPortalConstControl(), output.GetPortalConstControl());
TestValues(input.ReadPortal(), output.ReadPortal());
}
}

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

@ -23,7 +23,7 @@ template <typename T>
VTKM_CONT void TestValues(const vtkm::cont::ArrayHandle<T>& ah,
const std::initializer_list<T>& expected)
{
auto portal = ah.GetPortalConstControl();
auto portal = ah.ReadPortal();
VTKM_TEST_ASSERT(expected.size() == static_cast<size_t>(ah.GetNumberOfValues()));
for (vtkm::Id i = 0; i < ah.GetNumberOfValues(); ++i)
{

8
vtkm/cont/testing/UnitTestArrayHandleCartesianProduct.cxx
View File

@ -50,11 +50,9 @@ void ArrayHandleCPBasic(vtkm::cont::ArrayHandle<T> x,
vtkm::Id idx1 = (i % (nx * ny)) / nx;
vtkm::Id idx2 = i / (nx * ny);
val = vtkm::Vec<T, 3>(x.GetPortalConstControl().Get(idx0),
y.GetPortalConstControl().Get(idx1),
z.GetPortalConstControl().Get(idx2));
VTKM_TEST_ASSERT(test_equal(cpArray.GetPortalConstControl().Get(i), val),
"Wrong value in array");
val =
vtkm::Vec<T, 3>(x.ReadPortal().Get(idx0), y.ReadPortal().Get(idx1), z.ReadPortal().Get(idx2));
VTKM_TEST_ASSERT(test_equal(cpArray.ReadPortal().Get(i), val), "Wrong value in array");
}
}

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

@ -76,7 +76,7 @@ void CheckArray(const vtkm::cont::ArrayHandle<ValueType, C>& outArray,
ArrayHandleType arrayCopy;
vtkm::cont::ArrayCopy(outArray, arrayCopy);
typename ArrayHandleType::PortalConstControl portal = arrayCopy.GetPortalConstControl();
typename ArrayHandleType::ReadPortalType portal = arrayCopy.ReadPortal();
using VTraits = vtkm::VecTraits<ValueType>;
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
@ -246,7 +246,7 @@ void TrySpecialArrays()
VTKM_TEST_ASSERT(compositeArray.GetNumberOfValues() == ARRAY_SIZE, "Wrong array size.");
auto compositePortal = compositeArray.GetPortalConstControl();
auto compositePortal = compositeArray.ReadPortal();
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(test_equal(compositePortal.Get(index), vtkm::Id2(index, 295)), "Bad value.");

4
vtkm/cont/testing/UnitTestArrayHandleConcatenate.cxx
View File

@ -38,7 +38,7 @@ void TestArrayHandleConcatenate()
for (vtkm::Id index = 0; index < array5.GetNumberOfValues(); index++)
{
std::cout << array5.GetPortalConstControl().Get(index) << std::endl;
std::cout << array5.ReadPortal().Get(index) << std::endl;
}
}
@ -60,7 +60,7 @@ void TestConcatenateEmptyArray()
ArrayConcat2 arrConc2(arrConc, arr3);
for (vtkm::Id i = 0; i < arrConc2.GetNumberOfValues(); i++)
std::cout << arrConc2.GetPortalConstControl().Get(i) << std::endl;
std::cout << arrConc2.ReadPortal().Get(i) << std::endl;
}
} // namespace UnitTestArrayHandleIndexNamespace

8
vtkm/cont/testing/UnitTestArrayHandleCounting.cxx
View File

@ -79,7 +79,7 @@ struct TemplatedTests
using ArrayHandleType2 = vtkm::cont::ArrayHandle<ValueType, vtkm::cont::StorageTagCounting>;
using PortalType = typename ArrayHandleType::PortalConstControl;
using PortalType = typename ArrayHandleType::ReadPortalType;
void operator()(const ValueType& startingValue, const ValueType& step)
{
@ -102,12 +102,12 @@ struct TemplatedTests
ValueType properValue = startingValue;
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(arrayConst.GetPortalConstControl().Get(index) == properValue,
VTKM_TEST_ASSERT(arrayConst.ReadPortal().Get(index) == properValue,
"Counting array using constructor has unexpected value.");
VTKM_TEST_ASSERT(arrayMake.GetPortalConstControl().Get(index) == properValue,
VTKM_TEST_ASSERT(arrayMake.ReadPortal().Get(index) == properValue,
"Counting array using make has unexpected value.");
VTKM_TEST_ASSERT(arrayHandle.GetPortalConstControl().Get(index) == properValue,
VTKM_TEST_ASSERT(arrayHandle.ReadPortal().Get(index) == properValue,
"Counting array using raw array handle + tag has unexpected value.");
properValue = properValue + step;
}

34
vtkm/cont/testing/UnitTestArrayHandleDecorator.cxx
View File

@ -318,7 +318,7 @@ struct DecoratorTests
vtkm::cont::make_ArrayHandleDecorator(ARRAY_SIZE, InvertibleDecorImpl{}, ah1, ah2, ah3Copy);
{
auto portalDecor = ahDecor.GetPortalConstControl();
auto portalDecor = ahDecor.ReadPortal();
VTKM_TEST_ASSERT(ahDecor.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalDecor.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalDecor.Get(0) == ValueType{ 23 });
@ -338,7 +338,7 @@ struct DecoratorTests
ahDecor);
{ // Accessing portal should give all 25s:
auto portalDecor = ahDecor.GetPortalConstControl();
auto portalDecor = ahDecor.ReadPortal();
VTKM_TEST_ASSERT(ahDecor.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalDecor.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalDecor.Get(0) == ValueType{ 25 });
@ -354,7 +354,7 @@ struct DecoratorTests
}
{ // ah3Copy should have updated values:
auto portalAH3Copy = ah3Copy.GetPortalConstControl();
auto portalAH3Copy = ah3Copy.ReadPortal();
VTKM_TEST_ASSERT(ahDecor.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalAH3Copy.GetNumberOfValues() == ARRAY_SIZE);
VTKM_TEST_ASSERT(portalAH3Copy.Get(0) == ValueType{ 15 });
@ -383,9 +383,9 @@ struct DecoratorTests
auto decorArray = vtkm::cont::make_ArrayHandleDecorator(ARRAY_SIZE, impl, ahCount, ahConst);
{
auto decorPortal = decorArray.GetPortalConstControl();
auto countPortal = ahCount.GetPortalConstControl();
auto constPortal = ahConst.GetPortalConstControl();
auto decorPortal = decorArray.ReadPortal();
auto countPortal = ahCount.ReadPortal();
auto constPortal = ahConst.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
VTKM_TEST_ASSERT(decorPortal.Get(i) == op(countPortal.Get(i), constPortal.Get(i)));
@ -395,9 +395,9 @@ struct DecoratorTests
vtkm::cont::ArrayHandle<ValueType> copiedInExec;
vtkm::cont::ArrayCopy(decorArray, copiedInExec);
{
auto copiedPortal = copiedInExec.GetPortalConstControl();
auto countPortal = ahCount.GetPortalConstControl();
auto constPortal = ahConst.GetPortalConstControl();
auto copiedPortal = copiedInExec.ReadPortal();
auto countPortal = ahCount.ReadPortal();
auto constPortal = ahConst.ReadPortal();
for (vtkm::Id i = 0; i < ARRAY_SIZE; ++i)
{
VTKM_TEST_ASSERT(copiedPortal.Get(i) == op(countPortal.Get(i), constPortal.Get(i)));
@ -425,8 +425,8 @@ struct DecoratorTests
ARRAY_SIZE, ScanExtendedToNumIndicesDecorImpl<ValueType>{}, scan);
{
auto origPortal = numIndicesOrig.GetPortalConstControl();
auto decorPortal = numIndicesDecor.GetPortalConstControl();
auto origPortal = numIndicesOrig.ReadPortal();
auto decorPortal = numIndicesDecor.ReadPortal();
VTKM_STATIC_ASSERT(VTKM_PASS_COMMAS(
std::is_same<decltype(origPortal.Get(0)), decltype(decorPortal.Get(0))>::value));
VTKM_TEST_ASSERT(origPortal.GetNumberOfValues() == decorPortal.GetNumberOfValues());
@ -450,7 +450,7 @@ struct DecoratorTests
decor.Allocate(5);
VTKM_TEST_ASSERT(decor.GetNumberOfValues() == 5);
{
auto decorPortal = decor.GetPortalControl();
auto decorPortal = decor.WritePortal();
decorPortal.Set(0, 13);
decorPortal.Set(1, 8);
decorPortal.Set(2, 43);
@ -460,7 +460,7 @@ struct DecoratorTests
VTKM_TEST_ASSERT(a1.GetNumberOfValues() == 5);
{
auto a1Portal = a1.GetPortalConstControl();
auto a1Portal = a1.ReadPortal();
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(0), 1));
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(1), 0));
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(2), 4));
@ -470,7 +470,7 @@ struct DecoratorTests
VTKM_TEST_ASSERT(a2.GetNumberOfValues() == 5);
{
auto a2Portal = a2.GetPortalConstControl();
auto a2Portal = a2.ReadPortal();
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(0), 3));
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(1), 8));
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(2), 3));
@ -481,7 +481,7 @@ struct DecoratorTests
decor.Shrink(3);
VTKM_TEST_ASSERT(decor.GetNumberOfValues() == 3);
{
auto decorPortal = decor.GetPortalConstControl();
auto decorPortal = decor.ReadPortal();
VTKM_TEST_ASSERT(test_equal(decorPortal.Get(0), 13));
VTKM_TEST_ASSERT(test_equal(decorPortal.Get(1), 8));
VTKM_TEST_ASSERT(test_equal(decorPortal.Get(2), 43));
@ -489,7 +489,7 @@ struct DecoratorTests
VTKM_TEST_ASSERT(a1.GetNumberOfValues() == 3);
{
auto a1Portal = a1.GetPortalConstControl();
auto a1Portal = a1.ReadPortal();
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(0), 1));
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(1), 0));
VTKM_TEST_ASSERT(test_equal(a1Portal.Get(2), 4));
@ -497,7 +497,7 @@ struct DecoratorTests
VTKM_TEST_ASSERT(a2.GetNumberOfValues() == 3);
{
auto a2Portal = a2.GetPortalConstControl();
auto a2Portal = a2.ReadPortal();
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(0), 3));
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(1), 8));
VTKM_TEST_ASSERT(test_equal(a2Portal.Get(2), 3));

4
vtkm/cont/testing/UnitTestArrayHandleDiscard.cxx
View File

@ -35,7 +35,7 @@ struct Test
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<DeviceTag>;
using Handle = vtkm::cont::ArrayHandle<ValueType>;
using DiscardHandle = vtkm::cont::ArrayHandleDiscard<ValueType>;
using OutputPortal = typename Handle::PortalControl;
using OutputPortal = typename Handle::WritePortalType;
using ReduceOp = vtkm::Add;
// Test discard arrays by using the ReduceByKey algorithm. Two regular arrays
@ -68,7 +68,7 @@ struct Test
Algorithm::SortByKey(keys, values);
Algorithm::ReduceByKey(keys, values, output_keys, output_values, op);
OutputPortal outputs = output_values.GetPortalControl();
OutputPortal outputs = output_values.WritePortal();
VTKM_TEST_ASSERT(outputs.GetNumberOfValues() == NUM_KEYS,
"Unexpected number of output values from ReduceByKey.");

16
vtkm/cont/testing/UnitTestArrayHandleExtractComponent.cxx
View File

@ -87,8 +87,8 @@ struct ExtractComponentTests
using RefVectorType = typename ReferenceCompositeArray::ValueType;
using Traits = vtkm::VecTraits<RefVectorType>;
auto testPortal = testArray.GetPortalConstControl();
auto refPortal = this->RefComposite.GetPortalConstControl();
auto testPortal = testArray.ReadPortal();
auto refPortal = this->RefComposite.ReadPortal();
VTKM_TEST_ASSERT(testPortal.GetNumberOfValues() == refPortal.GetNumberOfValues(),
"Number of values in read test output do not match input.");
@ -137,14 +137,16 @@ struct ExtractComponentTests
InputArray composite = this->BuildInputArray();
ExtractArray extract(composite, component);
WriteTestFunctor<typename ExtractArray::PortalControl,
typename ReferenceCompositeArray::PortalConstControl>
functor(extract.GetPortalControl(), this->RefComposite.GetPortalConstControl(), component);
{
WriteTestFunctor<typename ExtractArray::WritePortalType,
typename ReferenceCompositeArray::ReadPortalType>
functor(extract.WritePortal(), this->RefComposite.ReadPortal(), component);
for (vtkm::Id i = 0; i < extract.GetNumberOfValues(); ++i)
{
functor(i);
}
}
this->ValidateWriteTestArray(composite, component);
}
@ -177,8 +179,8 @@ struct ExtractComponentTests
using Traits = vtkm::VecTraits<VectorType>;
// Check that the indicated component is twice the reference value.
auto refPortal = this->RefComposite.GetPortalConstControl();
auto portal = testArray.GetPortalConstControl();
auto refPortal = this->RefComposite.ReadPortal();
auto portal = testArray.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == refPortal.GetNumberOfValues(),
"Number of values in write test output do not match input.");

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

@ -75,7 +75,7 @@ struct CopyValue : public vtkm::worklet::WorkletMapField
template <typename T, typename S>
void verify_results(vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, S> const& handle)
{
auto portal = handle.GetPortalConstControl();
auto portal = handle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == static_cast<vtkm::Id>(correct_x_coords.size()),
"coordinate portal size is incorrect");

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

@ -47,7 +47,7 @@ struct ImplicitTests
//verify that the control portal works
for (int i = 0; i < ARRAY_SIZE; ++i)
{
const ValueType v = implict.GetPortalConstControl().Get(i);
const ValueType v = implict.ReadPortal().Get(i);
const ValueType correct_value = functor(i);
VTKM_TEST_ASSERT(v == correct_value, "Implicit Handle Failed");
}

3
vtkm/cont/testing/UnitTestArrayHandleIndex.cxx
View File

@ -24,8 +24,7 @@ void TestArrayHandleIndex()
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(index) == index,
"Index array has unexpected value.");
VTKM_TEST_ASSERT(array.ReadPortal().Get(index) == index, "Index array has unexpected value.");
}
}

12
vtkm/cont/testing/UnitTestArrayHandlePermutation.cxx
View File

@ -218,9 +218,9 @@ struct PermutationTests
VTKM_TEST_ASSERT(permutationArray.GetNumberOfValues() == ARRAY_SIZE,
"Permutation array wrong size.");
VTKM_TEST_ASSERT(permutationArray.GetPortalControl().GetNumberOfValues() == ARRAY_SIZE,
VTKM_TEST_ASSERT(permutationArray.WritePortal().GetNumberOfValues() == ARRAY_SIZE,
"Permutation portal wrong size.");
VTKM_TEST_ASSERT(permutationArray.GetPortalConstControl().GetNumberOfValues() == ARRAY_SIZE,
VTKM_TEST_ASSERT(permutationArray.ReadPortal().GetNumberOfValues() == ARRAY_SIZE,
"Permutation portal wrong size.");
vtkm::cont::Token token;
@ -233,15 +233,15 @@ struct PermutationTests
Algorithm::Schedule(make_InPlacePermutationFunctor(permutationArray, Device(), token),
ARRAY_SIZE);
token.DetachFromAll();
CheckInPlaceResult(valueArray.GetPortalControl());
CheckInPlaceResult(valueArray.GetPortalConstControl());
CheckInPlaceResult(valueArray.WritePortal());
CheckInPlaceResult(valueArray.ReadPortal());
std::cout << "Try output operation" << std::endl;
Algorithm::Schedule(make_OutputPermutationFunctor(permutationArray, Device(), token),
ARRAY_SIZE);
token.DetachFromAll();
CheckOutputResult(valueArray.GetPortalConstControl());
CheckOutputResult(valueArray.GetPortalControl());
CheckOutputResult(valueArray.ReadPortal());
CheckOutputResult(valueArray.WritePortal());
}
};

13
vtkm/cont/testing/UnitTestArrayHandleReverse.cxx
View File

@ -26,8 +26,7 @@ void TestArrayHandleReverseRead()
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(index) == index,
"Index array has unexpected value.");
VTKM_TEST_ASSERT(array.ReadPortal().Get(index) == index, "Index array has unexpected value.");
}
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandleIndex> reverse =
@ -35,8 +34,7 @@ void TestArrayHandleReverseRead()
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(reverse.GetPortalConstControl().Get(index) ==
array.GetPortalConstControl().Get(9 - index),
VTKM_TEST_ASSERT(reverse.ReadPortal().Get(index) == array.ReadPortal().Get(9 - index),
"ArrayHandleReverse does not reverse array");
}
}
@ -51,12 +49,12 @@ void TestArrayHandleReverseWrite()
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
reverse.GetPortalControl().Set(index, index);
reverse.WritePortal().Set(index, index);
}
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
VTKM_TEST_ASSERT(handle.GetPortalConstControl().Get(index) == (9 - index),
VTKM_TEST_ASSERT(handle.ReadPortal().Get(index) == (9 - index),
"ArrayHandleReverse does not reverse array");
}
}
@ -80,8 +78,7 @@ void TestArrayHandleReverseScanInclusiveByKey()
vtkm::cont::make_ArrayHandleReverse(vtkm::cont::make_ArrayHandle(expected, 10));
for (int i = 0; i < 10; i++)
{
VTKM_TEST_ASSERT(output.GetPortalConstControl().Get(i) ==
expected_reversed.GetPortalConstControl().Get(i),
VTKM_TEST_ASSERT(output.ReadPortal().Get(i) == expected_reversed.ReadPortal().Get(i),
"ArrayHandleReverse as output of ScanInclusiveByKey");
}
std::cout << std::endl;

14
vtkm/cont/testing/UnitTestArrayHandleSwizzle.cxx
View File

@ -121,8 +121,8 @@ struct SwizzleTests
VTKM_TEST_ASSERT(testArray.GetNumberOfValues() == this->RefArray.GetNumberOfValues(),
"Number of values incorrect in Read test.");
auto refPortal = this->RefArray.GetPortalConstControl();
auto testPortal = testArray.GetPortalConstControl();
auto refPortal = this->RefArray.ReadPortal();
auto testPortal = testArray.ReadPortal();
SwizzleVectorType refVecSwizzle(vtkm::TypeTraits<SwizzleVectorType>::ZeroInitialization());
for (vtkm::Id i = 0; i < testArray.GetNumberOfValues(); ++i)
@ -178,13 +178,15 @@ struct SwizzleTests
SwizzleInputArrayType input = this->BuildSwizzleInputArray();
auto swizzle = vtkm::cont::make_ArrayHandleSwizzle(input, map);
WriteTestFunctor<typename SwizzleArrayType<OutSize>::PortalControl> functor(
swizzle.GetPortalControl());
{
WriteTestFunctor<typename SwizzleArrayType<OutSize>::WritePortalType> functor(
swizzle.WritePortal());
for (vtkm::Id i = 0; i < swizzle.GetNumberOfValues(); ++i)
{
functor(i);
}
}
this->ValidateWriteTestArray(input, map);
}
@ -203,8 +205,8 @@ struct SwizzleTests
template <vtkm::IdComponent OutSize>
void ValidateWriteTestArray(SwizzleInputArrayType testArray, const MapType<OutSize>& map) const
{
auto refPortal = this->RefArray.GetPortalConstControl();
auto portal = testArray.GetPortalConstControl();
auto refPortal = this->RefArray.ReadPortal();
auto portal = testArray.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == refPortal.GetNumberOfValues(),
"Number of values in write test output do not match input.");

4
vtkm/cont/testing/UnitTestArrayHandleThreadSafety.cxx
View File

@ -140,7 +140,7 @@ template <typename Storage>
void ThreadsCheckArray(vtkm::cont::ArrayHandle<ValueType, Storage> array)
{
std::cout << " Check array in control environment" << std::endl;
auto portal = array.GetPortalConstControl();
auto portal = array.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == ARRAY_SIZE);
std::cout << " Starting threads to check" << std::endl;
@ -177,7 +177,7 @@ void ThreadsDecrementArray(vtkm::cont::ArrayHandle<ValueType, Storage> array)
VTKM_TEST_ASSERT(futureResult, "Failure in DecrementArray");
}
CheckPortal(array.GetPortalConstControl());
CheckPortal(array.ReadPortal());
}
template <typename Storage>

14
vtkm/cont/testing/UnitTestArrayHandleTransform.cxx
View File

@ -78,14 +78,14 @@ VTKM_CONT void CheckControlPortals(const OriginalArrayHandleType& originalArray,
{
std::cout << " Verify that the control portal works" << std::endl;
using OriginalPortalType = typename OriginalArrayHandleType::PortalConstControl;
using TransformedPortalType = typename TransformedArrayHandleType::PortalConstControl;
using OriginalPortalType = typename OriginalArrayHandleType::ReadPortalType;
using TransformedPortalType = typename TransformedArrayHandleType::ReadPortalType;
VTKM_TEST_ASSERT(originalArray.GetNumberOfValues() == transformedArray.GetNumberOfValues(),
"Number of values in transformed array incorrect.");
OriginalPortalType originalPortal = originalArray.GetPortalConstControl();
TransformedPortalType transformedPortal = transformedArray.GetPortalConstControl();
OriginalPortalType originalPortal = originalArray.ReadPortal();
TransformedPortalType transformedPortal = transformedArray.ReadPortal();
VTKM_TEST_ASSERT(originalPortal.GetNumberOfValues() == transformedPortal.GetNumberOfValues(),
"Number of values in transformed portal incorrect.");
@ -139,10 +139,10 @@ struct TransformTests
vtkm::cont::ArrayHandle<InputValueType> input;
TransformHandle thandle(input, functor);
using Portal = typename vtkm::cont::ArrayHandle<InputValueType>::PortalControl;
using Portal = typename vtkm::cont::ArrayHandle<InputValueType>::WritePortalType;
input.Allocate(ARRAY_SIZE);
{
Portal portal = input.GetPortalControl();
Portal portal = input.WritePortal();
for (vtkm::Id index = 0; index < ARRAY_SIZE; ++index)
{
portal.Set(index, TestValue(index, InputValueType()));
@ -159,7 +159,7 @@ struct TransformTests
std::cout << "Modify array handle values to ensure transform gets updated" << std::endl;
{
Portal portal = input.GetPortalControl();
Portal portal = input.WritePortal();
for (vtkm::Id index = 0; index < ARRAY_SIZE; ++index)
{
portal.Set(index, TestValue(index * index, InputValueType()));

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

@ -32,7 +32,7 @@ void TestArrayHandleUniformPointCoordinates()
"Array computed wrong number of points.");
std::cout << "Getting array portal." << std::endl;
vtkm::internal::ArrayPortalUniformPointCoordinates portal = arrayHandle.GetPortalConstControl();
vtkm::internal::ArrayPortalUniformPointCoordinates portal = arrayHandle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == NUM_POINTS, "Portal has wrong number of points.");
VTKM_TEST_ASSERT(portal.GetRange3() == DIMENSIONS, "Portal range is wrong.");

Some files were not shown because too many files have changed in this diff Show More