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

Improvements to moving data into ArrayHandle

Browse Source 
We have made several improvements to adding data into an `ArrayHandle`.

## Moving data from an `std::vector`

For numerous reasons, it is convenient to define data in a `std::vector`
and then wrap that into an `ArrayHandle`. It is often the case that an
`std::vector` is filled and then becomes unused once it is converted to an
`ArrayHandle`. In this case, what we really want is to pass the data off to
the `ArrayHandle` so that the `ArrayHandle` is now managing the data and
not the `std::vector`.

C++11 has a mechanism to do this: move semantics. You can now pass
variables to functions as an "rvalue" (right-hand value). When something is
passed as an rvalue, it can pull state out of that variable and move it
somewhere else. `std::vector` implements this movement so that an rvalue
can be moved to another `std::vector` without actually copying the data.
`make_ArrayHandle` now also takes advantage of this feature to move rvalue
`std::vector`s.

There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove`
that takes an rvalue. There is also a special overload of
`make_ArrayHandle` itself that handles an rvalue `vector`. (However, using
the explicit move version is better if you want to make sure the data is
actually moved.)

## Make `ArrayHandle` from initalizer list

A common use case for using `std::vector` (particularly in our unit tests)
is to quickly add an initalizer list into an `ArrayHandle`. Now you can
by simply passing an initializer list to `make_ArrayHandle`.

## Deprecated `make_ArrayHandle` with default shallow copy

For historical reasons, passing an `std::vector` or a pointer to
`make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`).
Although more efficient, this mode is inherintly unsafe, and making it the
default is asking for trouble.

To combat this, calling `make_ArrayHandle` without a copy flag is
deprecated. In this way, if you wish to do the faster but more unsafe
creation of an `ArrayHandle` you should explicitly express that.

This requried quite a few changes through the VTK-m source (particularly in
the tests).

## Similar changes to `Field`

`vtkm::cont::Field` has a `make_Field` helper function that is similar to
`make_ArrayHandle`. It also features the ability to create fields from
`std::vector`s and C arrays. It also likewise had the same unsafe behavior
by default of not copying from the source of the arrays.

That behavior has similarly been depreciated. You now have to specify a
copy flag.

The ability to construct a `Field` from an initializer list of values has
also been added.
This commit is contained in:
Kenneth Moreland 2020-07-16 10:32:32 -06:00
parent 744edbf428
commit d1a4aecc59
96 changed files with 1229 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
benchmarking/BenchmarkArrayTransfer.cxx
View File

@ -97,8 +97,8 @@ void BenchContToExecRead(benchmark::State& state)
state.SetLabel(desc.str());
}
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::cont::Invoker invoker{ device };
vtkm::cont::Timer timer{ device };
@ -181,8 +181,8 @@ void BenchContToExecReadWrite(benchmark::State& state)
state.SetLabel(desc.str());
}
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::cont::Invoker invoker{ device };
vtkm::cont::Timer timer{ device };
@ -223,8 +223,8 @@ void BenchRoundTripRead(benchmark::State& state)
state.SetLabel(desc.str());
}
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
std::vector<ValueType> vec(static_cast<std::size_t>(numValues), 2);
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::cont::Invoker invoker{ device };
vtkm::cont::Timer timer{ device };
@ -277,7 +277,7 @@ void BenchRoundTripReadWrite(benchmark::State& state)
}
std::vector<ValueType> vec(static_cast<std::size_t>(numValues));
ArrayType array = vtkm::cont::make_ArrayHandle(vec);
ArrayType array = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::cont::Invoker invoker{ device };
vtkm::cont::Timer timer{ device };

120
docs/changelog/move-std-vector.md Normal file
View File

@ -0,0 +1,120 @@
# Improvements to moving data into ArrayHandle
We have made several improvements to adding data into an `ArrayHandle`.
## Moving data from an `std::vector`
For numerous reasons, it is convenient to define data in a `std::vector`
and then wrap that into an `ArrayHandle`. There are two obvious ways to do
this. First, you could deep copy the data into an `ArrayHandle`, which has
obvious drawbacks. Second, you could take the pointer for the data in the
`std::vector` and use that as user-allocated memory in the `ArrayHandle`
without deep copying it. The problem with this shallow copy is that it is
unsafe. If the `std::vector` goes out of scope (or gets resized), then the
data the `ArrayHandle` is pointing to becomes unallocated, which will lead
to unpredictable behavior.
However, there is a third option. It is often the case that an
`std::vector` is filled and then becomes unused once it is converted to an
`ArrayHandle`. In this case, what we really want is to pass the data off to
the `ArrayHandle` so that the `ArrayHandle` is now managing the data and
not the `std::vector`.
C++11 has a mechanism to do this: move semantics. You can now pass
variables to functions as an "rvalue" (right-hand value). When something is
passed as an rvalue, it can pull state out of that variable and move it
somewhere else. `std::vector` implements this movement so that an rvalue
can be moved to another `std::vector` without actually copying the data.
`make_ArrayHandle` now also takes advantage of this feature to move rvalue
`std::vector`s.
There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove`
that takes an rvalue. There is also a special overload of
`make_ArrayHandle` itself that handles an rvalue `vector`. (However, using
the explicit move version is better if you want to make sure the data is
actually moved.)
So if you create the `std::vector` in the call to `make_ArrayHandle`, then
the data only gets created once.
``` cpp
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>{ 2, 6, 1, 7, 4, 3, 9 });
```
Note that there is now a better way to express an initializer list to
`ArrayHandle` documented below. But this form of `ArrayHandleMove` can be
particularly useful for initializing an array to all of a particular value.
For example, an easy way to initialize an array of 1000 elements all to 1
is
``` cpp
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>(1000, 1));
```
You can also move the data from an already created `std::vector` by using
the `std::move` function to convert it to an rvalue. When you do this, the
`std::vector` becomes invalid after the call and any use will be undefined.
``` cpp
std::vector<vtkm::Id> vector;
// fill vector
auto array = vtkm::cont::make_ArrayHandleMove(std::move(vector));
```
## Make `ArrayHandle` from initalizer list
A common use case for using `std::vector` (particularly in our unit tests)
is to quickly add an initalizer list into an `ArrayHandle`. Repeating the
example from above:
``` cpp
auto array = vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>{ 2, 6, 1, 7, 4, 3, 9 });
```
However, creating the `std::vector` should be unnecessary. Why not be able
to create the `ArrayHandle` directly from an initializer list? Now you can
by simply passing an initializer list to `make_ArrayHandle`.
``` cpp
auto array = vtkm::cont::make_ArrayHandle({ 2, 6, 1, 7, 4, 3, 9 });
```
There is an issue here. The type here can be a little ambiguous (for
humans). In this case, `array` will be of type
`vtkm::cont::ArrayHandleBasic<int>`, since that is what an integer literal
defaults to. This could be a problem if, for example, you want to use
`array` as an array of `vtkm::Id`, which could be of type `vtkm::Int64`.
This is easily remedied by specifying the desired value type as a template
argument to `make_ArrayHandle`.
``` cpp
auto array = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 2, 6, 1, 7, 4, 3, 9 });
```
## Deprecated `make_ArrayHandle` with default shallow copy
For historical reasons, passing an `std::vector` or a pointer to
`make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`).
Although more efficient, this mode is inherintly unsafe, and making it the
default is asking for trouble.
To combat this, calling `make_ArrayHandle` without a copy flag is
deprecated. In this way, if you wish to do the faster but more unsafe
creation of an `ArrayHandle` you should explicitly express that.
This requried quite a few changes through the VTK-m source (particularly in
the tests).
## Similar changes to `Field`
`vtkm::cont::Field` has a `make_Field` helper function that is similar to
`make_ArrayHandle`. It also features the ability to create fields from
`std::vector`s and C arrays. It also likewise had the same unsafe behavior
by default of not copying from the source of the arrays.
That behavior has similarly been depreciated. You now have to specify a
copy flag.
The ability to construct a `Field` from an initializer list of values has
also been added.

6
examples/cosmotools/CosmoCenterFinder.cxx
View File

@ -52,11 +52,11 @@ void TestCosmoCenterFinder(const char* fileName)
}
vtkm::cont::ArrayHandle<vtkm::Float32> xLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles);
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles);
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles);
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles, vtkm::CopyFlag::Off);
// Output MBP particleId pairs array
vtkm::Pair<vtkm::Id, vtkm::Float32> nxnResult;

10
examples/cosmotools/CosmoHaloFinder.cxx
View File

@ -53,11 +53,11 @@ void TestCosmoHaloFinder(const char* fileName)
}
vtkm::cont::ArrayHandle<vtkm::Float32> xLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(xLocation, nParticles);
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(xLocation, nParticles);
vtkm::cont::ArrayHandle<vtkm::Float32> yLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(yLocation, nParticles);
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(yLocation, nParticles);
vtkm::cont::ArrayHandle<vtkm::Float32> zLocArray =
vtkm::cont::make_ArrayHandle<vtkm::Float32>(zLocation, nParticles);
vtkm::cont::make_ArrayHandleMove<vtkm::Float32>(zLocation, nParticles);
// Output halo id, mbp id and min potential per particle
vtkm::cont::ArrayHandle<vtkm::Id> resultHaloId;
@ -88,10 +88,6 @@ void TestCosmoHaloFinder(const char* fileName)
xLocArray.ReleaseResources();
yLocArray.ReleaseResources();
zLocArray.ReleaseResources();
delete[] xLocation;
delete[] yLocation;
delete[] zLocation;
}
/////////////////////////////////////////////////////////////////////

2
examples/particle_advection/ParticleAdvection.cxx
View File

@ -71,7 +71,7 @@ int main(int argc, char** argv)
p.ID = i;
seeds.push_back(p);
}
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
//compute streamlines
vtkm::filter::Streamline streamline;

193
vtkm/cont/ArrayHandleBasic.h
View File

@ -175,12 +175,11 @@ public:
{
}
template <typename Deleter>
ArrayHandleBasic(
T* array,
vtkm::Id numberOfValues,
vtkm::cont::DeviceAdapterId device,
Deleter deleter,
vtkm::cont::internal::BufferInfo::Deleter deleter,
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
vtkm::cont::internal::MakeBuffer(device,
@ -192,6 +191,39 @@ public:
{
}
ArrayHandleBasic(
T* array,
void* container,
vtkm::Id numberOfValues,
vtkm::cont::internal::BufferInfo::Deleter deleter,
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
vtkm::cont::internal::MakeBuffer(vtkm::cont::DeviceAdapterTagUndefined{},
array,
container,
internal::detail::NumberOfBytes(numberOfValues, sizeof(T)),
deleter,
reallocater) })
{
}
ArrayHandleBasic(
T* array,
void* container,
vtkm::Id numberOfValues,
vtkm::cont::DeviceAdapterId device,
vtkm::cont::internal::BufferInfo::Deleter deleter,
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::InvalidRealloc)
: Superclass(std::vector<vtkm::cont::internal::Buffer>{
vtkm::cont::internal::MakeBuffer(device,
array,
container,
internal::detail::NumberOfBytes(numberOfValues, sizeof(T)),
deleter,
reallocater) })
{
}
/// @{
/// \brief Gets raw access to the `ArrayHandle`'s data.
///
@ -238,11 +270,85 @@ public:
/// @}
};
namespace internal
{
// Deletes a container object by casting it to a pointer of a given type (the template argument)
// and then using delete[] on the object.
template <typename T>
VTKM_CONT inline void SimpleArrayDeleter(void* container_)
{
T* container = reinterpret_cast<T*>(container_);
delete[] container;
}
// Reallocates a standard C array. Note that the allocation method is different than the default
// host allocation of vtkm::cont::internal::BufferInfo and may be less efficient.
template <typename T>
VTKM_CONT inline void SimpleArrayReallocater(void*& memory,
void*& container,
vtkm::BufferSizeType oldSize,
vtkm::BufferSizeType newSize)
{
VTKM_ASSERT(memory == container);
VTKM_ASSERT(static_cast<std::size_t>(newSize) % sizeof(T) == 0);
// If the new size is not much smaller than the old size, just reuse the buffer (and waste a
// little memory).
if ((newSize > ((3 * oldSize) / 4)) && (newSize <= oldSize))
{
return;
}
void* newBuffer = new T[static_cast<std::size_t>(newSize) / sizeof(T)];
std::memcpy(newBuffer, memory, static_cast<std::size_t>(newSize < oldSize ? newSize : oldSize));
if (memory != nullptr)
{
SimpleArrayDeleter<T>(memory);
}
memory = container = newBuffer;
}
// Deletes a container object by casting it to a pointer of a given type (the template argument)
// and then using delete on the object.
template <typename T>
VTKM_CONT inline void CastDeleter(void* container_)
{
T* container = reinterpret_cast<T*>(container_);
delete container;
}
template <typename T, typename Allocator>
VTKM_CONT inline void StdVectorDeleter(void* container)
{
CastDeleter<std::vector<T, Allocator>>(container);
}
template <typename T, typename Allocator>
VTKM_CONT inline void StdVectorReallocater(void*& memory,
void*& container,
vtkm::BufferSizeType oldSize,
vtkm::BufferSizeType newSize)
{
using vector_type = std::vector<T, Allocator>;
vector_type* vector = reinterpret_cast<vector_type*>(container);
VTKM_ASSERT(memory == &vector->front());
VTKM_ASSERT(oldSize == static_cast<vtkm::BufferSizeType>(vector->size()));
vector->resize(static_cast<std::size_t>(newSize));
memory = &vector->front();
}
} // namespace internal
/// A convenience function for creating an ArrayHandle from a standard C array.
///
template <typename T>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T>
make_ArrayHandle(const T* array, vtkm::Id numberOfValues, vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const T* array,
vtkm::Id numberOfValues,
vtkm::CopyFlag copy)
{
if (copy == vtkm::CopyFlag::On)
{
@ -258,12 +364,35 @@ make_ArrayHandle(const T* array, vtkm::Id numberOfValues, vtkm::CopyFlag copy =
}
}
template <typename T>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const T* array, vtkm::Id numberOfValues)
{
return make_ArrayHandle(array, numberOfValues, vtkm::CopyFlag::Off);
}
/// A convenience function to move a user-allocated array into an `ArrayHandle`.
/// The provided array pointer will be reset to `nullptr`.
/// If the array was not allocated with the `new[]` operator, then deleter and reallocater
/// functions must be provided.
///
template <typename T>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(
T*& array,
vtkm::Id numberOfValues,
vtkm::cont::internal::BufferInfo::Deleter deleter = internal::SimpleArrayDeleter<T>,
vtkm::cont::internal::BufferInfo::Reallocater reallocater = internal::SimpleArrayReallocater<T>)
{
vtkm::cont::ArrayHandleBasic<T> arrayHandle(array, numberOfValues, deleter, reallocater);
array = nullptr;
return arrayHandle;
}
/// A convenience function for creating an ArrayHandle from an std::vector.
///
template <typename T, typename Allocator>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(
const std::vector<T, Allocator>& array,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const std::vector<T, Allocator>& array,
vtkm::CopyFlag copy)
{
if (!array.empty())
{
@ -275,6 +404,56 @@ VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(
return vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>();
}
}
template <typename T, typename Allocator>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(const std::vector<T, Allocator>& array)
{
return make_ArrayHandle(array, vtkm::CopyFlag::Off);
}
/// Move an std::vector into an ArrayHandle.
///
template <typename T, typename Allocator>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandleMove(std::vector<T, Allocator>&& array)
{
using vector_type = std::vector<T, Allocator>;
vector_type* container = new vector_type(std::move(array));
return vtkm::cont::ArrayHandleBasic<T>(container->data(),
container,
static_cast<vtkm::Id>(container->size()),
internal::StdVectorDeleter<T, Allocator>,
internal::StdVectorReallocater<T, Allocator>);
}
template <typename T, typename Allocator>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::vector<T, Allocator>&& array,
vtkm::CopyFlag copy)
{
if (copy == vtkm::CopyFlag::On)
{
VTKM_LOG_S(
vtkm::cont::LogLevel::Info,
"CopyFlag states std::vector should be copied, but it can be moved. Ignoring copy flag.");
}
if (!array.empty())
{
return make_ArrayHandle(&array.front(), static_cast<vtkm::Id>(array.size()), copy);
}
else
{
// Vector empty. Just return an empty array handle.
return vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>();
}
}
/// Create an ArrayHandle directly from an initializer list of values.
///
template <typename T>
VTKM_CONT vtkm::cont::ArrayHandleBasic<T> make_ArrayHandle(std::initializer_list<T>&& values)
{
return make_ArrayHandle(values.begin(), static_cast<vtkm::Id>(values.size()), vtkm::CopyFlag::On);
}
}
} // namespace vtkm::cont

12
vtkm/cont/ArrayHandleExtrudeCoords.h
View File

@ -63,16 +63,8 @@ vtkm::cont::ArrayHandleExtrudeCoords<T> make_ArrayHandleExtrudeCoords(
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
{
using StorageType = vtkm::cont::internal::Storage<vtkm::Vec<T, 3>, internal::StorageTagExtrude>;
if (copy == vtkm::CopyFlag::Off)
{
return ArrayHandleExtrudeCoords<T>(StorageType(array, length, numberOfPlanes, cylindrical));
}
else
{
auto storage = StorageType(
vtkm::cont::make_ArrayHandle(array, length, vtkm::CopyFlag::On), numberOfPlanes, cylindrical);
return ArrayHandleExtrudeCoords<T>(storage);
}
return ArrayHandleExtrudeCoords<T>(
StorageType(vtkm::cont::make_ArrayHandle(array, length, copy), numberOfPlanes, cylindrical));
}
template <typename T>

76
vtkm/cont/ArrayHandleSOA.h
View File

@ -456,19 +456,44 @@ public:
template <typename... RemainingVectors>
ArrayHandleSOA(vtkm::CopyFlag copy,
const std::vector<ComponentType>& vector0,
const RemainingVectors&... componentVectors)
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(vector0, copy),
vtkm::cont::make_ArrayHandle(componentVectors, copy)...))
RemainingVectors&&... componentVectors)
: Superclass(StorageType(
vtkm::cont::make_ArrayHandle(vector0, copy),
vtkm::cont::make_ArrayHandle(std::forward<RemainingVectors>(componentVectors), copy)...))
{
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
}
// This only works if all the templated arguments are of type std::vector<ComponentType>.
template <typename... RemainingVectors>
ArrayHandleSOA(vtkm::CopyFlag copy,
std::vector<ComponentType>&& vector0,
RemainingVectors&&... componentVectors)
: Superclass(StorageType(
vtkm::cont::make_ArrayHandle(std::move(vector0), copy),
vtkm::cont::make_ArrayHandle(std::forward<RemainingVectors>(componentVectors), copy)...))
{
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
}
// This only works if all the templated arguments are of type std::vector<ComponentType>.
template <typename... RemainingVectors>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
ArrayHandleSOA(const std::vector<ComponentType>& vector0,
const RemainingVectors&... componentVectors)
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(vector0),
vtkm::cont::make_ArrayHandle(componentVectors)...))
: Superclass(
StorageType(vtkm::cont::make_ArrayHandle(vector0, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(componentVectors, vtkm::CopyFlag::Off)...))
{
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
}
// This only works if all the templated arguments are of type std::vector<ComponentType>.
template <typename... RemainingVectors>
ArrayHandleSOA(std::vector<ComponentType>&& vector0, RemainingVectors&&... componentVectors)
: Superclass(StorageType(
vtkm::cont::make_ArrayHandleMove(std::move(vector0)),
vtkm::cont::make_ArrayHandleMove(std::forward<RemainingVectors>(componentVectors))...))
{
VTKM_STATIC_ASSERT(sizeof...(RemainingVectors) + 1 == Traits::NUM_COMPONENTS);
}
@ -501,11 +526,13 @@ public:
// This only works if all the templated arguments are of type std::vector<ComponentType>.
template <typename... RemainingArrays>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
ArrayHandleSOA(vtkm::Id length,
const ComponentType* array0,
const RemainingArrays&... componentArrays)
: Superclass(StorageType(vtkm::cont::make_ArrayHandle(array0, length),
vtkm::cont::make_ArrayHandle(componentArrays, length)...))
: Superclass(
StorageType(vtkm::cont::make_ArrayHandle(array0, length, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(componentArrays, length, vtkm::CopyFlag::Off)...))
{
VTKM_STATIC_ASSERT(sizeof...(RemainingArrays) + 1 == Traits::NUM_COMPONENTS);
}
@ -558,18 +585,33 @@ VTKM_CONT
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>
make_ArrayHandleSOA(vtkm::CopyFlag copy,
const std::vector<ComponentType>& vector0,
const RemainingVectors&... componentVectors)
RemainingVectors&&... componentVectors)
{
return ArrayHandleSOA<
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
vector0, componentVectors..., copy);
copy, vector0, std::forward<RemainingVectors>(componentVectors)...);
}
// This only works if all the templated arguments are of type std::vector<ComponentType>.
template <typename ComponentType, typename... RemainingVectors>
VTKM_CONT
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>
make_ArrayHandleSOA(const std::vector<ComponentType>& vector0,
const RemainingVectors&... componentVectors)
make_ArrayHandleSOA(vtkm::CopyFlag copy,
std::vector<ComponentType>&& vector0,
RemainingVectors&&... componentVectors)
{
return ArrayHandleSOA<
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
copy, std::move(vector0), std::forward<RemainingVectors>(componentVectors)...);
}
template <typename ComponentType, typename... RemainingVectors>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
VTKM_CONT ArrayHandleSOA<
vtkm::Vec<ComponentType,
vtkm::IdComponent(sizeof...(RemainingVectors) +
1)>> make_ArrayHandleSOA(const std::vector<ComponentType>& vector0,
const RemainingVectors&... componentVectors)
{
return ArrayHandleSOA<
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingVectors) + 1)>>(
@ -601,11 +643,13 @@ VTKM_CONT
}
template <typename ComponentType, typename... RemainingArrays>
VTKM_CONT
ArrayHandleSOA<vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingArrays) + 1)>>
make_ArrayHandleSOA(vtkm::Id length,
const ComponentType* array0,
const RemainingArrays*... componentArrays)
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_ArrayHandle.")
VTKM_CONT ArrayHandleSOA<
vtkm::Vec<ComponentType,
vtkm::IdComponent(sizeof...(RemainingArrays) +
1)>> make_ArrayHandleSOA(vtkm::Id length,
const ComponentType* array0,
const RemainingArrays*... componentArrays)
{
return ArrayHandleSOA<
vtkm::Vec<ComponentType, vtkm::IdComponent(sizeof...(RemainingArrays) + 1)>>(

17
vtkm/cont/CellSetExtrude.h
View File

@ -168,10 +168,23 @@ CellSetExtrude make_CellSetExtrude(const std::vector<vtkm::Int32>& conn,
const std::vector<vtkm::Int32>& nextNode,
bool periodic = true)
{
return CellSetExtrude{ vtkm::cont::make_ArrayHandle(conn),
return CellSetExtrude{ vtkm::cont::make_ArrayHandle(conn, vtkm::CopyFlag::On),
static_cast<vtkm::Int32>(coords.GetNumberOfPointsPerPlane()),
coords.GetNumberOfPlanes(),
vtkm::cont::make_ArrayHandle(nextNode),
vtkm::cont::make_ArrayHandle(nextNode, vtkm::CopyFlag::On),
periodic };
}
template <typename T>
CellSetExtrude make_CellSetExtrude(std::vector<vtkm::Int32>&& conn,
const vtkm::cont::ArrayHandleExtrudeCoords<T>& coords,
std::vector<vtkm::Int32>&& nextNode,
bool periodic = true)
{
return CellSetExtrude{ vtkm::cont::make_ArrayHandleMove(std::move(conn)),
static_cast<vtkm::Int32>(coords.GetNumberOfPointsPerPlane()),
coords.GetNumberOfPlanes(),
vtkm::cont::make_ArrayHandleMove(std::move(nextNode)),
periodic };
}
}

15
vtkm/cont/ColorTable.cxx
View File

@ -833,15 +833,20 @@ ColorTable::TransferState ColorTable::GetExecutionDataForTransfer() const
if (this->Impl->ColorArraysChanged)
{
this->Impl->ColorPosHandle = vtkm::cont::make_ArrayHandle(this->Impl->ColorNodePos);
this->Impl->ColorRGBHandle = vtkm::cont::make_ArrayHandle(this->Impl->ColorRGB);
this->Impl->ColorPosHandle =
vtkm::cont::make_ArrayHandle(this->Impl->ColorNodePos, vtkm::CopyFlag::Off);
this->Impl->ColorRGBHandle =
vtkm::cont::make_ArrayHandle(this->Impl->ColorRGB, vtkm::CopyFlag::Off);
}
if (this->Impl->OpacityArraysChanged)
{
this->Impl->OpacityPosHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityNodePos);
this->Impl->OpacityAlphaHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityAlpha);
this->Impl->OpacityMidSharpHandle = vtkm::cont::make_ArrayHandle(this->Impl->OpacityMidSharp);
this->Impl->OpacityPosHandle =
vtkm::cont::make_ArrayHandle(this->Impl->OpacityNodePos, vtkm::CopyFlag::Off);
this->Impl->OpacityAlphaHandle =
vtkm::cont::make_ArrayHandle(this->Impl->OpacityAlpha, vtkm::CopyFlag::Off);
this->Impl->OpacityMidSharpHandle =
vtkm::cont::make_ArrayHandle(this->Impl->OpacityMidSharp, vtkm::CopyFlag::Off);
}
TransferState state = { (this->Impl->ColorArraysChanged || this->Impl->OpacityArraysChanged ||

6
vtkm/cont/DataSetBuilderRectilinear.h
View File

@ -27,7 +27,8 @@ class VTKM_CONT_EXPORT DataSetBuilderRectilinear
template <typename T, typename U>
VTKM_CONT static void CopyInto(const std::vector<T>& input, vtkm::cont::ArrayHandle<U>& output)
{
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input), output);
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input, vtkm::CopyFlag::Off),
output);
}
template <typename T, typename U>
@ -40,7 +41,8 @@ class VTKM_CONT_EXPORT DataSetBuilderRectilinear
template <typename T, typename U>
VTKM_CONT static void CopyInto(const T* input, vtkm::Id len, vtkm::cont::ArrayHandle<U>& output)
{
DataSetBuilderRectilinear::CopyInto(vtkm::cont::make_ArrayHandle(input, len), output);
DataSetBuilderRectilinear::CopyInto(
vtkm::cont::make_ArrayHandle(input, len, vtkm::CopyFlag::Off), output);
}
public:

51
vtkm/cont/Field.h
View File

@ -181,20 +181,67 @@ vtkm::cont::Field make_Field(std::string name,
Field::Association association,
const T* data,
vtkm::Id size,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
vtkm::CopyFlag copy)
{
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, size, copy));
}
template <typename T>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_Field.")
vtkm::cont::Field
make_Field(std::string name, Field::Association association, const T* data, vtkm::Id size)
{
return make_Field(name, association, data, size, vtkm::CopyFlag::Off);
}
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::Association association,
const std::vector<T>& data,
vtkm::CopyFlag copy = vtkm::CopyFlag::Off)
vtkm::CopyFlag copy)
{
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandle(data, copy));
}
template <typename T>
VTKM_DEPRECATED(1.6, "Specify a vtkm::CopyFlag or use a move version of make_Field.")
vtkm::cont::Field
make_Field(std::string name, Field::Association association, const std::vector<T>& data)
{
return make_Field(name, association, data, vtkm::CopyFlag::Off);
}
template <typename T>
vtkm::cont::Field make_FieldMove(std::string name,
Field::Association association,
std::vector<T>&& data)
{
return vtkm::cont::Field(name, association, vtkm::cont::make_ArrayHandleMove(data));
}
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::Association association,
std::vector<T>&& data,
vtkm::CopyFlag copy)
{
if (copy == vtkm::CopyFlag::On)
{
VTKM_LOG_S(
vtkm::cont::LogLevel::Info,
"CopyFlag states std::vector should be copied, but it can be moved. Ignoring copy flag.");
}
return make_FieldMove(name, association, std::move(data));
}
template <typename T>
vtkm::cont::Field make_Field(std::string name,
Field::Association association,
std::initializer_list<T>&& data)
{
return make_FieldMove(name, association, vtkm::cont::make_ArrayHandle(std::move(data)));
}
//@}
/// Convenience function to build point fields from vtkm::cont::ArrayHandle

9
vtkm/cont/StorageExtrude.h
View File

@ -395,15 +395,6 @@ public:
{
}
// Create with externally managed memory
Storage(const BaseT* array, vtkm::Id arrayLength, vtkm::Int32 numberOfPlanes, bool cylindrical)
: Array(vtkm::cont::make_ArrayHandle(array, arrayLength))
, NumberOfPlanes(numberOfPlanes)
, UseCylindrical(cylindrical)
{
VTKM_ASSERT(this->Array.GetNumberOfValues() >= 0);
}
Storage(const HandleType& array, vtkm::Int32 numberOfPlanes, bool cylindrical)
: Array(array)
, NumberOfPlanes(numberOfPlanes)

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

@ -51,7 +51,7 @@ struct TryArrayInType
}
using ArrayHandleType = vtkm::cont::ArrayHandle<T>;
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE);
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE, vtkm::CopyFlag::Off);
using PortalType = typename ArrayHandleType::template ExecutionTypes<Device>::PortalConst;

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

@ -49,7 +49,7 @@ struct TryArrayInOutType
}
using ArrayHandleType = vtkm::cont::ArrayHandle<T>;
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE);
ArrayHandleType handle = vtkm::cont::make_ArrayHandle(array, ARRAY_SIZE, vtkm::CopyFlag::Off);
using PortalType = typename ArrayHandleType::template ExecutionTypes<Device>::Portal;

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

@ -177,7 +177,7 @@ private:
arrayHandle.ReleaseResourcesExecution();
arrayHandle = vtkm::cont::ArrayHandle<T>();
arrayHandle.ReleaseResources();
arrayHandle = vtkm::cont::make_ArrayHandle(std::vector<T>());
arrayHandle = vtkm::cont::make_ArrayHandleMove(std::vector<T>());
arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
arrayHandle = vtkm::cont::ArrayHandle<T>();
arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
@ -361,6 +361,144 @@ private:
}
};
struct VerifyVectorMovedMemory
{
template <typename T>
VTKM_CONT void operator()(T) const
{
std::cout << "Creating moved std::vector memory." << std::endl;
std::vector<T> buffer(ARRAY_SIZE);
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[static_cast<std::size_t>(index)] = TestValue(index, T());
}
vtkm::cont::ArrayHandle<T> arrayHandle = vtkm::cont::make_ArrayHandleMove(std::move(buffer));
// buffer is now invalid
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE,
"ArrayHandle has wrong number of entries.");
std::cout << "Check array with moved std::vector memory." << std::endl;
array_handle_testing::CheckArray(arrayHandle);
std::cout << "Check out execution array behavior." << std::endl;
{ //as input
vtkm::cont::Token token;
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::PortalConst
executionPortal;
executionPortal = arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
token.DetachFromAll();
//use a worklet to verify the input transfer worked properly
vtkm::cont::ArrayHandle<T> result;
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
array_handle_testing::CheckArray(result);
}
std::cout << "Check out inplace." << std::endl;
{ //as inplace
vtkm::cont::Token token;
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::Portal
executionPortal;
executionPortal = arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
token.DetachFromAll();
//use a worklet to verify the inplace transfer worked properly
vtkm::cont::ArrayHandle<T> result;
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
array_handle_testing::CheckArray(result);
}
std::cout << "Check out output." << std::endl;
{ //as output with same length as user provided. This should work
//as no new memory needs to be allocated
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(ARRAY_SIZE, DeviceAdapterTag(), token);
token.DetachFromAll();
//we can't verify output contents as those aren't fetched, we
//can just make sure the allocation didn't throw an exception
}
{ //as a vector moved to the ArrayHandle, reallocation should be possible
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
token.DetachFromAll();
//we can't verify output contents as those aren't fetched, we
//can just make sure the allocation didn't throw an exception
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE * 2);
}
}
};
struct VerifyInitializerList
{
template <typename T>
VTKM_CONT void operator()(T) const
{
std::cout << "Creating array with initializer list memory." << std::endl;
vtkm::cont::ArrayHandle<T> arrayHandle =
vtkm::cont::make_ArrayHandle({ TestValue(0, T()), TestValue(1, T()), TestValue(2, T()) });
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == 3,
"ArrayHandle has wrong number of entries.");
std::cout << "Check array with initializer list memory." << std::endl;
array_handle_testing::CheckArray(arrayHandle);
std::cout << "Check out execution array behavior." << std::endl;
{ //as input
vtkm::cont::Token token;
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::PortalConst
executionPortal;
executionPortal = arrayHandle.PrepareForInput(DeviceAdapterTag(), token);
token.DetachFromAll();
//use a worklet to verify the input transfer worked properly
vtkm::cont::ArrayHandle<T> result;
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
array_handle_testing::CheckArray(result);
}
std::cout << "Check out inplace." << std::endl;
{ //as inplace
vtkm::cont::Token token;
typename vtkm::cont::ArrayHandle<T>::template ExecutionTypes<DeviceAdapterTag>::Portal
executionPortal;
executionPortal = arrayHandle.PrepareForInPlace(DeviceAdapterTag(), token);
token.DetachFromAll();
//use a worklet to verify the inplace transfer worked properly
vtkm::cont::ArrayHandle<T> result;
DispatcherPassThrough().Invoke(arrayHandle, WrapPortal(executionPortal), result);
array_handle_testing::CheckArray(result);
}
std::cout << "Check out output." << std::endl;
{ //as output with same length as user provided. This should work
//as no new memory needs to be allocated
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(3, DeviceAdapterTag(), token);
token.DetachFromAll();
//we can't verify output contents as those aren't fetched, we
//can just make sure the allocation didn't throw an exception
}
{ //as a vector moved to the ArrayHandle, reallocation should be possible
vtkm::cont::Token token;
arrayHandle.PrepareForOutput(ARRAY_SIZE * 2, DeviceAdapterTag(), token);
token.DetachFromAll();
//we can't verify output contents as those aren't fetched, we
//can just make sure the allocation didn't throw an exception
VTKM_TEST_ASSERT(arrayHandle.GetNumberOfValues() == ARRAY_SIZE * 2);
}
}
};
struct VerifyVTKMAllocatedHandle
{
template <typename T>
@ -497,11 +635,13 @@ private:
{
void operator()() const
{
vtkm::testing::Testing::TryTypes(VerifyEmptyArrays());
vtkm::testing::Testing::TryTypes(VerifyUserOwnedMemory());
vtkm::testing::Testing::TryTypes(VerifyUserTransferredMemory());
vtkm::testing::Testing::TryTypes(VerifyVTKMAllocatedHandle());
vtkm::testing::Testing::TryTypes(VerifyEqualityOperators());
vtkm::testing::Testing::TryTypes(VerifyEmptyArrays{});
vtkm::testing::Testing::TryTypes(VerifyUserOwnedMemory{});
vtkm::testing::Testing::TryTypes(VerifyUserTransferredMemory{});
vtkm::testing::Testing::TryTypes(VerifyVectorMovedMemory{});
vtkm::testing::Testing::TryTypes(VerifyInitializerList{});
vtkm::testing::Testing::TryTypes(VerifyVTKMAllocatedHandle{});
vtkm::testing::Testing::TryTypes(VerifyEqualityOperators{});
}
};

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

@ -170,7 +170,8 @@ public:
pointsVec.push_back(point);
}
vtkm::cont::ArrayHandle<PointType> points = vtkm::cont::make_ArrayHandle(pointsVec);
vtkm::cont::ArrayHandle<PointType> points =
vtkm::cont::make_ArrayHandle(pointsVec, vtkm::CopyFlag::Off);
// Initialize locator
vtkm::cont::CellLocatorRectilinearGrid locator;

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

@ -145,7 +145,8 @@ public:
pointsVec.push_back(vtkm::make_Vec(0, 4, 4));
pointsVec.push_back(vtkm::make_Vec(4, 0, 4));
vtkm::cont::ArrayHandle<PointType> points = vtkm::cont::make_ArrayHandle(pointsVec);
vtkm::cont::ArrayHandle<PointType> points =
vtkm::cont::make_ArrayHandle(pointsVec, vtkm::CopyFlag::Off);
// Query the points using the locators.
vtkm::cont::ArrayHandle<vtkm::Id> cellIds;
vtkm::cont::ArrayHandle<PointType> parametric;

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

@ -177,9 +177,7 @@ public:
vtkm::cont::ColorTable table(range, rgb1, rgb2, rgbspace);
VTKM_TEST_ASSERT(table.GetClamping() == true, "clamping not setup properly");
constexpr vtkm::Id nvals = 4;
constexpr int data[nvals] = { -1, 0, 1, 2 };
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ -1, 0, 1, 2 });
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
const bool ran = table.Map(field, colors);
@ -202,9 +200,7 @@ public:
table.SetClampingOff();
VTKM_TEST_ASSERT(table.GetClamping() == false, "clamping not setup properly");
constexpr vtkm::Id nvals = 4;
constexpr int data[nvals] = { -2, -1, 2, 3 };
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ -2, -1, 2, 3 });
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
const bool ran = table.Map(field, colors);
@ -249,9 +245,7 @@ public:
"rescaled has incorrect number of control points");
//Verify that the rescaled color table generates correct colors
constexpr vtkm::Id nvals = 6;
constexpr int data[nvals] = { 0, 10, 20, 30, 40, 50 };
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ 0, 10, 20, 30, 40, 50 });
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
const bool ran = newTable.Map(field, colors);
@ -284,11 +278,8 @@ public:
VTKM_TEST_ASSERT(table.GetNumberOfPoints() == 4,
"adding points caused number of control points to be wrong");
constexpr vtkm::Id nvals = 3;
constexpr float data[nvals] = { 10.0f, -5.0f, -15.0f };
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ 10.0f, -5.0f, -15.0f });
const bool ran = table.Map(field, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");
@ -322,11 +313,8 @@ public:
VTKM_TEST_ASSERT(opacityData[3] == 0.0, "rescale modified mid/sharp of opacity");
constexpr vtkm::Id nvals = 6;
constexpr int data[nvals] = { 0, 10, 20, 30, 40, 50 };
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ 0, 10, 20, 30, 40, 50 });
const bool ran = table.Map(field, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");
@ -366,11 +354,8 @@ public:
"removing points didn't update range");
table.RescaleToRange(vtkm::Range{ 0.0, 50.0 });
constexpr vtkm::Id nvals = 6;
constexpr float data[nvals] = { 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f };
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f });
const bool ran = table.Map(field, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");
@ -424,11 +409,8 @@ public:
"removing points didn't update range");
table.RescaleToRange(vtkm::Range{ 0.0, 50.0 });
constexpr vtkm::Id nvals = 6;
constexpr float data[nvals] = { 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f };
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ 0.0f, 10.0f, 20.0f, 30.0f, 40.0f, 50.0f });
const bool ran = table.Map(field, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");
@ -454,9 +436,7 @@ public:
VTKM_TEST_ASSERT((table.GetNumberOfPoints() == 21),
"loading linear green table failed with number of control points");
constexpr vtkm::Id nvals = 3;
constexpr double data[3] = { 0.0, 0.5, 1.0 };
auto samples = vtkm::cont::make_ArrayHandle(data, nvals);
auto samples = vtkm::cont::make_ArrayHandle({ 0.0, 0.5, 1.0 });
vtkm::cont::ArrayHandle<vtkm::Vec4ui_8> colors;
{
@ -503,11 +483,8 @@ public:
table.Sample(256, samples);
VTKM_TEST_ASSERT((samples.Samples.GetNumberOfValues() == 260), "invalid sample length");
constexpr vtkm::Id nvals = 8;
constexpr int data[nvals] = { -1, 0, 10, 20, 30, 40, 50, 60 };
vtkm::cont::ArrayHandle<vtkm::Vec3ui_8> colors;
auto field = vtkm::cont::make_ArrayHandle(data, nvals);
auto field = vtkm::cont::make_ArrayHandle({ -1, 0, 10, 20, 30, 40, 50, 60 });
const bool ran = table.Map(field, samples, colors);
VTKM_TEST_ASSERT(ran, "color table failed to execute");

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

@ -51,8 +51,8 @@ private:
std::random_device rng;
std::mt19937 urng(rng());
std::shuffle(data, data + nvals, urng);
auto field =
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, data, nvals);
auto field = vtkm::cont::make_Field(
"TestField", vtkm::cont::Field::Association::POINTS, data, nvals, vtkm::CopyFlag::Off);
vtkm::Range result;
field.GetRange(&result);
@ -78,8 +78,8 @@ private:
fieldData[j][i] = data[j];
}
}
auto field =
vtkm::cont::make_Field("TestField", vtkm::cont::Field::Association::POINTS, fieldData, nvals);
auto field = vtkm::cont::make_Field(
"TestField", vtkm::cont::Field::Association::POINTS, fieldData, nvals, vtkm::CopyFlag::Off);
vtkm::Range result[NumberOfComponents];
field.GetRange(result, CustomTypeList());

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

@ -971,7 +971,7 @@ private:
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
}
IdArrayHandle input = vtkm::cont::make_ArrayHandle(&(*testData.begin()), ARRAY_SIZE);
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
//make a deep copy of input and place it into temp
IdArrayHandle temp;
@ -1017,7 +1017,7 @@ private:
randomData[5] = 955; // 3 (lower), 4 (upper)
//change the control structure under the handle
input = vtkm::cont::make_ArrayHandle(randomData, RANDOMDATA_SIZE);
input = vtkm::cont::make_ArrayHandle(randomData, RANDOMDATA_SIZE, vtkm::CopyFlag::Off);
FloatCastHandle tempCast(temp);
Algorithm::Copy(input, tempCast);
@ -1064,7 +1064,7 @@ private:
testData[i] = static_cast<vtkm::Id>(OFFSET + ((ARRAY_SIZE - i) % 50));
}
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
IdArrayHandle sorted;
Algorithm::Copy(unsorted, sorted);
@ -1095,7 +1095,7 @@ private:
}
//sort the users memory in-place
IdArrayHandle sorted = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle sorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
Algorithm::Sort(sorted);
//copy the sorted array into our own memory, if use the same user ptr
@ -1136,7 +1136,7 @@ private:
testData[i] = static_cast<vtkm::Id>(OFFSET + ((ARRAY_SIZE - i) % 50));
}
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle unsorted = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
IdArrayHandle sorted;
Algorithm::Copy(unsorted, sorted);
@ -1202,8 +1202,8 @@ private:
testValues[index] = TestValue(i, Vec3());
}
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(testKeys);
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(testKeys, vtkm::CopyFlag::Off);
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
Algorithm::SortByKey(keys, values);
@ -1261,7 +1261,7 @@ private:
{
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
}
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
//make a deep copy of input and place it into temp
IdArrayHandle temp;
@ -1297,7 +1297,7 @@ private:
{
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
}
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
//make a deep copy of input and place it into temp
IdArrayHandle temp;
@ -1408,7 +1408,7 @@ private:
}
testData[ARRAY_SIZE / 2] = maxValue;
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
vtkm::Id2 range = Algorithm::Reduce(input, vtkm::Id2(0, 0), vtkm::MinAndMax<vtkm::Id>());
VTKM_TEST_ASSERT(maxValue == range[1], "Got bad value from Reduce with comparison object");
@ -1430,27 +1430,24 @@ private:
std::cout << " Reduce bool array with vtkm::LogicalAnd to see if all values are true."
<< std::endl;
//construct an array of bools and verify that they aren't all true
constexpr vtkm::Id inputLength = 60;
constexpr bool inputValues[inputLength] = {
true, true, true, true, true, true, false, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true, true, true, true, true, true
};
auto barray = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
auto barray =
vtkm::cont::make_ArrayHandle({ true, true, true, true, true, true, false, true, true, true,
true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true,
true, true, true, true, true, true, true, true, true, true });
bool all_true = Algorithm::Reduce(barray, true, vtkm::LogicalAnd());
VTKM_TEST_ASSERT(all_true == false, "reduction with vtkm::LogicalAnd should return false");
std::cout << " Reduce with custom value type and custom comparison operator." << std::endl;
//test with a custom value type with the reduction value being a vtkm::Vec<float,2>
constexpr CustomTForReduce inputFValues[inputLength] = {
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 413.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -11.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -211.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 113.1f, -2.1f, -1.0f
};
auto farray = vtkm::cont::make_ArrayHandle(inputFValues, inputLength);
auto farray = vtkm::cont::make_ArrayHandle<CustomTForReduce>(
{ 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 413.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -11.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -211.1f, -1.0f,
13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 13.1f, -2.1f, -1.0f, 113.1f, -2.1f, -1.0f });
vtkm::Vec2f_32 frange =
Algorithm::Reduce(farray, vtkm::Vec2f_32(0.0f, 0.0f), CustomMinAndMax<CustomTForReduce>());
VTKM_TEST_ASSERT(-211.1f == frange[0],
@ -1494,20 +1491,15 @@ private:
{
//lastly test with heterogeneous zip values ( vec3, and constant array handle),
//and a custom reduce binary functor
const vtkm::Id indexLength = 30;
const vtkm::Id valuesLength = 10;
using ValueType = vtkm::Float32;
vtkm::Id indexs[indexLength] = { 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,
5, 5, 5, 1, 4, 9, 7, 7, 7, 8, 8, 8, 0, 1, 2 };
ValueType values[valuesLength] = {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, -2.0f
};
const ValueType expectedSum = 125;
IdArrayHandle indexHandle =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4,
5, 5, 5, 1, 4, 9, 7, 7, 7, 8, 8, 8, 0, 1, 2 });
vtkm::cont::ArrayHandle<ValueType> valueHandle = vtkm::cont::make_ArrayHandle(
{ 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, -2.0f });
IdArrayHandle indexHandle = vtkm::cont::make_ArrayHandle(indexs, indexLength);
vtkm::cont::ArrayHandle<ValueType> valueHandle =
vtkm::cont::make_ArrayHandle(values, valuesLength);
const ValueType expectedSum = 125;
vtkm::cont::ArrayHandlePermutation<IdArrayHandle, vtkm::cont::ArrayHandle<ValueType>> perm;
perm = vtkm::cont::make_ArrayHandlePermutation(indexHandle, valueHandle);
@ -1526,15 +1518,14 @@ private:
//first test with very basic integer key / values
{
const vtkm::Id inputLength = 12;
const vtkm::Id expectedLength = 6;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 }; // in keys
vtkm::Id inputValues[inputLength] = { 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 }; // in values
vtkm::IdComponent expectedKeys[expectedLength] = { 0, 1, 4, 0, 2, -1 };
vtkm::Id expectedValues[expectedLength] = { 10, 2, 0, 3, 10, -42 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 });
IdArrayHandle values =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 });
IdComponentArrayHandle keysOut;
IdArrayHandle valuesOut;
@ -1560,22 +1551,19 @@ private:
//next test with a single key across the entire set, using vec3 as the
//value, using a custom reduce binary functor
{
const vtkm::Id inputLength = 3;
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0 });
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> values =
vtkm::cont::make_ArrayHandle({ vtkm::Vec3f_64(13.1, 13.3, 13.5),
vtkm::Vec3f_64(-2.1, -2.3, -2.5),
vtkm::Vec3f_64(-1.0, -1.0, 1.0) });
const vtkm::Id expectedLength = 1;
vtkm::Id inputKeys[inputLength] = { 0, 0, 0 }; // input keys
vtkm::Vec3f_64 inputValues[inputLength];
inputValues[0] = vtkm::make_Vec(13.1, 13.3, 13.5);
inputValues[1] = vtkm::make_Vec(-2.1, -2.3, -2.5);
inputValues[2] = vtkm::make_Vec(-1.0, -1.0, 1.0); // input keys
vtkm::Id expectedKeys[expectedLength] = { 0 };
vtkm::Vec3f_64 expectedValues[expectedLength];
expectedValues[0] = vtkm::make_Vec(27.51, 30.59, -33.75);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> values =
vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle keysOut;
vtkm::cont::ArrayHandle<vtkm::Vec3f_64, StorageTag> valuesOut;
Algorithm::ReduceByKey(keys, values, keysOut, valuesOut, vtkm::Multiply());
@ -1603,17 +1591,16 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Reduce By Key with Fancy Arrays" << std::endl;
const vtkm::Id inputLength = 12;
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 });
IdArrayHandle values =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 });
FloatCastHandle castValues(values);
const vtkm::Id expectedLength = 6;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 4, 0, 2, 2, 2, 2, -1 }; // in keys
vtkm::Id inputValues[inputLength] = { 13, -2, -1, 1, 1, 0, 3, 1, 2, 3, 4, -42 }; // in values
vtkm::IdComponent expectedKeys[expectedLength] = { 0, 1, 4, 0, 2, -1 };
vtkm::Id expectedValues[expectedLength] = { 10, 2, 0, 3, 10, -42 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
FloatCastHandle castValues(values);
IdComponentArrayHandle keysOut;
IdArrayHandle valuesOut;
FloatCastHandle castValuesOut(valuesOut);
@ -1640,21 +1627,14 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Inclusive By Key with 1 elements" << std::endl;
const vtkm::Id inputLength = 1;
vtkm::Id inputKeys[inputLength] = { 0 };
vtkm::Id inputValues[inputLength] = { 5 };
const vtkm::Id expectedLength = 1;
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 5 });
IdArrayHandle valuesOut;
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == 1, "Got wrong number of output values");
const vtkm::Id v = valuesOut.ReadPortal().Get(0);
VTKM_TEST_ASSERT(5 == v, "Incorrect scanned value");
}
@ -1664,16 +1644,12 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Exclusive By Key with 2 elements" << std::endl;
const vtkm::Id inputLength = 2;
vtkm::Id inputKeys[inputLength] = { 0, 1 };
vtkm::Id inputValues[inputLength] = { 1, 1 };
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1 });
const vtkm::Id expectedLength = 2;
vtkm::Id expectedValues[expectedLength] = { 1, 1 };
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle valuesOut;
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
@ -1692,8 +1668,7 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Inclusive By Key with " << ARRAY_SIZE << " elements" << std::endl;
const vtkm::Id inputLength = ARRAY_SIZE;
std::vector<vtkm::Id> inputKeys(inputLength);
std::vector<vtkm::Id> inputKeys(ARRAY_SIZE);
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
{
@ -1702,10 +1677,9 @@ private:
else
inputKeys[static_cast<std::size_t>(i)] = static_cast<vtkm::Id>(i);
}
std::vector<vtkm::Id> inputValues(inputLength, 1);
std::vector<vtkm::Id> inputValues(ARRAY_SIZE, 1);
const vtkm::Id expectedLength = ARRAY_SIZE;
std::vector<vtkm::Id> expectedValues(expectedLength);
std::vector<vtkm::Id> expectedValues(ARRAY_SIZE);
for (std::size_t i = 0; i < ARRAY_SIZE; i++)
{
if (i % 100 < 98)
@ -1714,17 +1688,17 @@ private:
expectedValues[i] = static_cast<vtkm::Id>(1);
}
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, vtkm::CopyFlag::Off);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
IdArrayHandle valuesOut;
Algorithm::ScanInclusiveByKey(keys, values, valuesOut, vtkm::Add());
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == ARRAY_SIZE,
"Got wrong number of output values");
auto values_portal = valuesOut.ReadPortal();
for (auto i = 0; i < expectedLength; i++)
for (auto i = 0; i < ARRAY_SIZE; i++)
{
const vtkm::Id v = values_portal.Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
@ -1735,16 +1709,13 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Inclusive By Key" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle valuesOut;
Algorithm::ScanInclusiveByKey(keys, values, valuesOut);
@ -1763,16 +1734,13 @@ private:
std::cout << "Testing Scan Inclusive By Key In Place" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
Algorithm::ScanInclusiveByKey(keys, values, values);
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
@ -1789,17 +1757,14 @@ private:
std::cout << "Testing Scan Inclusive By Key In Place with a Fancy Array" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
FloatCastHandle castValues(values);
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 1, 2, 3, 1, 2, 1, 1, 2, 3, 4 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
FloatCastHandle castValues(values);
Algorithm::ScanInclusiveByKey(keys, castValues, castValues);
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
@ -1816,15 +1781,12 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Exclusive By Key with 1 elements" << std::endl;
const vtkm::Id inputLength = 1;
vtkm::Id inputKeys[inputLength] = { 0 };
vtkm::Id inputValues[inputLength] = { 0 };
vtkm::Id init = 5;
const vtkm::Id expectedLength = 1;
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0 });
IdArrayHandle valuesOut;
@ -1841,17 +1803,14 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Exclusive By Key with 2 elements" << std::endl;
const vtkm::Id inputLength = 2;
vtkm::Id inputKeys[inputLength] = { 0, 1 };
vtkm::Id inputValues[inputLength] = { 1, 1 };
vtkm::Id init = 5;
IdArrayHandle keys = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1 });
const vtkm::Id expectedLength = 2;
vtkm::Id expectedValues[expectedLength] = { 5, 5 };
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle valuesOut;
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
@ -1871,8 +1830,7 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Exclusive By Key with " << ARRAY_SIZE << " elements" << std::endl;
const vtkm::Id inputLength = ARRAY_SIZE;
std::vector<vtkm::Id> inputKeys(inputLength);
std::vector<vtkm::Id> inputKeys(ARRAY_SIZE);
for (std::size_t i = 0; i < ARRAY_SIZE; i++)
{
if (i % 100 < 98)
@ -1880,11 +1838,10 @@ private:
else
inputKeys[i] = static_cast<vtkm::Id>(i);
}
std::vector<vtkm::Id> inputValues(inputLength, 1);
std::vector<vtkm::Id> inputValues(ARRAY_SIZE, 1);
vtkm::Id init = 5;
const vtkm::Id expectedLength = ARRAY_SIZE;
std::vector<vtkm::Id> expectedValues(expectedLength);
std::vector<vtkm::Id> expectedValues(ARRAY_SIZE);
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
{
if (i % 100 < 98)
@ -1893,17 +1850,17 @@ private:
expectedValues[static_cast<std::size_t>(i)] = init;
}
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues);
IdArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, vtkm::CopyFlag::Off);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
IdArrayHandle valuesOut;
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == expectedLength,
VTKM_TEST_ASSERT(valuesOut.GetNumberOfValues() == ARRAY_SIZE,
"Got wrong number of output values");
auto valuesPortal = valuesOut.ReadPortal();
for (vtkm::Id i = 0; i < expectedLength; i++)
for (vtkm::Id i = 0; i < ARRAY_SIZE; i++)
{
const vtkm::Id v = valuesPortal.Get(i);
VTKM_TEST_ASSERT(expectedValues[static_cast<std::size_t>(i)] == v, "Incorrect scanned value");
@ -1915,17 +1872,15 @@ private:
std::cout << "-------------------------------------------" << std::endl;
std::cout << "Testing Scan Exclusive By Key" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
vtkm::Id init = 5;
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
IdArrayHandle valuesOut;
Algorithm::ScanExclusiveByKey(keys, values, valuesOut, init, vtkm::Add());
@ -1945,17 +1900,15 @@ private:
std::cout << "Testing Scan Inclusive By Key In Place" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
vtkm::Id init = 5;
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
Algorithm::ScanExclusiveByKey(keys, values, values, init, vtkm::Add());
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
@ -1972,18 +1925,16 @@ private:
std::cout << "Testing Scan Inclusive By Key In Place with a Fancy Array" << std::endl;
const vtkm::Id inputLength = 10;
vtkm::IdComponent inputKeys[inputLength] = { 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 };
vtkm::Id inputValues[inputLength] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
vtkm::FloatDefault init = 5;
IdComponentArrayHandle keys =
vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 1, 1, 2, 3, 3, 3, 3 });
IdArrayHandle values = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 });
FloatCastHandle castValues(values);
const vtkm::Id expectedLength = 10;
vtkm::Id expectedValues[expectedLength] = { 5, 6, 7, 5, 6, 5, 5, 6, 7, 8 };
IdComponentArrayHandle keys = vtkm::cont::make_ArrayHandle(inputKeys, inputLength);
IdArrayHandle values = vtkm::cont::make_ArrayHandle(inputValues, inputLength);
FloatCastHandle castValues(values);
Algorithm::ScanExclusiveByKey(keys, castValues, castValues, init, vtkm::Add());
VTKM_TEST_ASSERT(values.GetNumberOfValues() == expectedLength,
"Got wrong number of output values");
@ -2049,7 +2000,7 @@ private:
inputValues[mid] = 0.0;
vtkm::cont::ArrayHandle<vtkm::Float64> array =
vtkm::cont::make_ArrayHandle(&inputValues[0], ARRAY_SIZE);
vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
vtkm::Float64 product = Algorithm::ScanInclusive(array, array, vtkm::Multiply());
@ -2082,7 +2033,7 @@ private:
{
testValues[i] = TestValue(1, Vec3());
}
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
Vec3 sum = Algorithm::ScanInclusive(values, values);
std::cout << "Sum that was returned " << sum << std::endl;
@ -2194,7 +2145,8 @@ private:
std::size_t mid = ARRAY_SIZE / 2;
inputValues[mid] = 0.0;
vtkm::cont::ArrayHandle<vtkm::Float64> array = vtkm::cont::make_ArrayHandle(inputValues);
vtkm::cont::ArrayHandle<vtkm::Float64> array =
vtkm::cont::make_ArrayHandle(inputValues, vtkm::CopyFlag::Off);
vtkm::Float64 initialValue = 2.00;
vtkm::Float64 product =
@ -2231,7 +2183,7 @@ private:
{
testValues[i] = TestValue(1, Vec3());
}
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues);
Vec3ArrayHandle values = vtkm::cont::make_ArrayHandle(testValues, vtkm::CopyFlag::Off);
Vec3 sum = Algorithm::ScanExclusive(values, values);
std::cout << "Sum that was returned " << sum << std::endl;
@ -2470,7 +2422,7 @@ private:
testData[i] = TestCopy<T>::get(index);
}
vtkm::cont::ArrayHandle<T> input = vtkm::cont::make_ArrayHandle(&testData[0], COPY_ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> input = vtkm::cont::make_ArrayHandle(testData, vtkm::CopyFlag::Off);
//make a deep copy of input and place it into temp
{
@ -2680,7 +2632,7 @@ private:
testData[i] = static_cast<vtkm::Id>(OFFSET + (i % 50));
}
IdArrayHandle input = vtkm::cont::make_ArrayHandle(testData);
IdArrayHandle input = vtkm::cont::make_ArrayHandle<vtkm::Id>(testData, vtkm::CopyFlag::Off);
//make a deep copy of input and place it into temp
vtkm::cont::ArrayHandle<vtkm::Float64> temp;
@ -2710,10 +2662,8 @@ private:
// a single atomic value.
std::cout << "Testing Atomic Add with vtkm::Int32" << std::endl;
{
std::vector<vtkm::Int32> singleElement;
singleElement.push_back(0);
vtkm::cont::ArrayHandle<vtkm::Int32> atomicElement =
vtkm::cont::make_ArrayHandle(singleElement);
vtkm::cont::make_ArrayHandle<vtkm::Int32>({ 0 });
vtkm::cont::AtomicArray<vtkm::Int32> atomic(atomicElement);
{
@ -2727,10 +2677,8 @@ private:
std::cout << "Testing Atomic Add with vtkm::Int64" << std::endl;
{
std::vector<vtkm::Int64> singleElement;
singleElement.push_back(0);
vtkm::cont::ArrayHandle<vtkm::Int64> atomicElement =
vtkm::cont::make_ArrayHandle(singleElement);
vtkm::cont::make_ArrayHandle<vtkm::Int64>({ 0 });
vtkm::cont::AtomicArray<vtkm::Int64> atomic(atomicElement);
{
@ -2744,10 +2692,8 @@ private:
std::cout << "Testing Atomic CAS with vtkm::Int32" << std::endl;
{
std::vector<vtkm::Int32> singleElement;
singleElement.push_back(0);
vtkm::cont::ArrayHandle<vtkm::Int32> atomicElement =
vtkm::cont::make_ArrayHandle(singleElement);
vtkm::cont::make_ArrayHandle<vtkm::Int32>({ 0 });
vtkm::cont::AtomicArray<vtkm::Int32> atomic(atomicElement);
{
@ -2761,10 +2707,8 @@ private:
std::cout << "Testing Atomic CAS with vtkm::Int64" << std::endl;
{
std::vector<vtkm::Int64> singleElement;
singleElement.push_back(0);
vtkm::cont::ArrayHandle<vtkm::Int64> atomicElement =
vtkm::cont::make_ArrayHandle(singleElement);
vtkm::cont::make_ArrayHandle<vtkm::Int64>({ 0 });
vtkm::cont::AtomicArray<vtkm::Int64> atomic(atomicElement);
{

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

@ -374,7 +374,7 @@ private:
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray =
vtkm::cont::make_ArrayHandleSOA(vector0, vector1, vector2);
vtkm::cont::make_ArrayHandleSOA(vtkm::CopyFlag::Off, vector0, vector1, vector2);
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.ReadPortal());
}
@ -388,7 +388,7 @@ private:
{
vtkm::cont::ArrayHandleSOA<Vec3> soaArray = vtkm::cont::make_ArrayHandleSOA(
ARRAY_SIZE, &vector0.front(), &vector1.front(), &vector2.front());
ARRAY_SIZE, vtkm::CopyFlag::Off, &vector0.front(), &vector1.front(), &vector2.front());
VTKM_TEST_ASSERT(soaArray.GetNumberOfValues() == ARRAY_SIZE);
CheckPortal(soaArray.ReadPortal());
}
@ -436,7 +436,7 @@ private:
const ValueType value = TestValue(13, ValueType());
std::vector<ValueType> compositeData(ARRAY_SIZE, value);
vtkm::cont::ArrayHandle<ValueType> compositeInput =
vtkm::cont::make_ArrayHandle(compositeData);
vtkm::cont::make_ArrayHandle(compositeData, vtkm::CopyFlag::Off);
auto composite =
vtkm::cont::make_ArrayHandleCompositeVector(compositeInput, compositeInput, compositeInput);
@ -597,7 +597,7 @@ private:
basicVec.push_back(ValueType(static_cast<ComponentType>(i)));
basicVec.push_back(ValueType(ComponentType(i)));
}
BasicArrayType basic = vtkm::cont::make_ArrayHandle(basicVec);
BasicArrayType basic = vtkm::cont::make_ArrayHandle(basicVec, vtkm::CopyFlag::Off);
// concatenate two arrays together
ConcatenateType concatenate = vtkm::cont::make_ArrayHandleConcatenate(implicit, basic);
@ -986,14 +986,9 @@ private:
{
using ValueType = vtkm::Vec<ComponentType, NUM_COMPONENTS>;
ComponentType testValues[ARRAY_SIZE * NUM_COMPONENTS];
for (vtkm::Id index = 0; index < ARRAY_SIZE * NUM_COMPONENTS; ++index)
{
testValues[index] = TestValue(index, ComponentType());
}
vtkm::cont::ArrayHandle<ComponentType> baseArray =
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE * NUM_COMPONENTS);
vtkm::cont::ArrayHandle<ComponentType> baseArray;
baseArray.Allocate(ARRAY_SIZE * NUM_COMPONENTS);
SetPortal(baseArray.WritePortal());
vtkm::cont::ArrayHandleGroupVec<vtkm::cont::ArrayHandle<ComponentType>, NUM_COMPONENTS>
groupArray(baseArray);
@ -1210,9 +1205,10 @@ private:
testKeys[i] = KeyType(static_cast<KeyComponentType>(ARRAY_SIZE - i));
testValues[i] = ValueType(static_cast<ValueComponentType>(i));
}
vtkm::cont::ArrayHandle<KeyType> keys = vtkm::cont::make_ArrayHandle(testKeys, ARRAY_SIZE);
vtkm::cont::ArrayHandle<KeyType> keys =
vtkm::cont::make_ArrayHandle(testKeys, ARRAY_SIZE, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<ValueType> values =
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE);
vtkm::cont::make_ArrayHandle(testValues, ARRAY_SIZE, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandleZip<vtkm::cont::ArrayHandle<KeyType>,
vtkm::cont::ArrayHandle<ValueType>>
@ -1425,7 +1421,7 @@ private:
ValueType(static_cast<ValueComponentType>(i)));
}
vtkm::cont::ArrayHandle<PairType> input =
vtkm::cont::make_ArrayHandle(testKeysAndValues, ARRAY_SIZE);
vtkm::cont::make_ArrayHandle(testKeysAndValues, ARRAY_SIZE, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<KeyType> result_keys;
vtkm::cont::ArrayHandle<ValueType> result_values;

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

@ -118,7 +118,7 @@ public:
coordi.push_back(vtkm::make_Vec(00.0f, 10.0f, 10.0f));
coordi.push_back(vtkm::make_Vec(10.0f, 00.0f, 10.0f));
coordi.push_back(vtkm::make_Vec(10.0f, 10.0f, 10.0f));
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi);
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::Off);
vtkm::cont::CoordinateSystem coord("points", coordi_Handle);
@ -145,7 +145,7 @@ public:
qcVec.push_back(vtkm::make_Vec(0.01f, 9.99f, 9.99f));
qcVec.push_back(vtkm::make_Vec(9.99f, 0.01f, 9.99f));
qcVec.push_back(vtkm::make_Vec(9.99f, 9.99f, 9.99f));
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec);
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<vtkm::Id> nnId_Handle;
vtkm::cont::ArrayHandle<vtkm::FloatDefault> nnDis_Handle;
@ -163,8 +163,7 @@ public:
vtkm::worklet::DispatcherMapField<NearestNeighborSearchBruteForce3DWorklet> nnsbf3DDispatcher(
nnsbf3dWorklet);
nnsbf3DDispatcher.SetDevice(DeviceAdapter());
nnsbf3DDispatcher.Invoke(
qc_Handle, vtkm::cont::make_ArrayHandle(coordi), bfnnId_Handle, bfnnDis_Handle);
nnsbf3DDispatcher.Invoke(qc_Handle, coordi_Handle, bfnnId_Handle, bfnnDis_Handle);
///// verify search result /////
bool passTest = true;

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

@ -53,8 +53,7 @@ void TryCopy()
}
{ // ArrayHandle ids
const std::vector<vtkm::Id> idsVec{ 3, 8, 7 };
const auto ids = vtkm::cont::make_ArrayHandle(idsVec);
const auto ids = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 3, 8, 7 });
{ // Return vector:
const std::vector<ValueType> output = vtkm::cont::ArrayGetValues(ids, data);
TestValues<ValueType>(output, { 3, 8, 7 });

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

@ -83,9 +83,9 @@ void RunTest()
createArr(Y, nY);
createArr(Z, nZ);
ArrayHandleCPBasic(vtkm::cont::make_ArrayHandle(X),
vtkm::cont::make_ArrayHandle(Y),
vtkm::cont::make_ArrayHandle(Z));
ArrayHandleCPBasic(vtkm::cont::make_ArrayHandle(X, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(Y, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(Z, vtkm::CopyFlag::Off));
}
}
}

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

@ -52,16 +52,7 @@ vtkm::cont::ArrayHandle<ValueType, StorageTag> MakeInputArray(int arrayId)
}
// Make an array handle that points to this buffer.
using ArrayHandleType = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
ArrayHandleType bufferHandle = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
// When this function returns, the array is going to go out of scope, which
// will invalidate the array handle we just created. So copy to a new buffer
// that will stick around after we return.
ArrayHandleType copyHandle;
vtkm::cont::ArrayCopy(bufferHandle, copyHandle);
return copyHandle;
return vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, vtkm::CopyFlag::On);
}
template <typename ValueType, typename C>

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

@ -54,7 +54,7 @@ void TestConcatenateEmptyArray()
using ArrayConcat = vtkm::cont::ArrayHandleConcatenate<CoeffArrayTypeTmp, CoeffArrayTypeTmp>;
using ArrayConcat2 = vtkm::cont::ArrayHandleConcatenate<ArrayConcat, CoeffArrayTypeTmp>;
CoeffArrayTypeTmp arr1 = vtkm::cont::make_ArrayHandle(vec);
CoeffArrayTypeTmp arr1 = vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
CoeffArrayTypeTmp arr2, arr3;
ArrayConcat arrConc(arr2, arr1);

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

@ -60,8 +60,8 @@ struct Test
}
// Prepare array handles:
Handle keys = vtkm::cont::make_ArrayHandle(keyData, ARRAY_SIZE);
Handle values = vtkm::cont::make_ArrayHandle(valueData, ARRAY_SIZE);
Handle keys = vtkm::cont::make_ArrayHandle(keyData, ARRAY_SIZE, vtkm::CopyFlag::Off);
Handle values = vtkm::cont::make_ArrayHandle(valueData, ARRAY_SIZE, vtkm::CopyFlag::Off);
DiscardHandle output_keys;
Handle output_values;

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

@ -96,7 +96,7 @@ int TestArrayHandleExtrude()
const int numPlanes = 8;
auto coords = vtkm::cont::make_ArrayHandleExtrudeCoords(
vtkm::cont::make_ArrayHandle(points_rz), numPlanes, false);
vtkm::cont::make_ArrayHandle(points_rz, vtkm::CopyFlag::Off), numPlanes, false);
VTKM_TEST_ASSERT(coords.GetNumberOfValues() ==
static_cast<vtkm::Id>(((points_rz.size() / 2) * numPlanes)),

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

@ -196,14 +196,7 @@ struct PermutationTests
}
// Create an ArrayHandle from the buffer
ValueArrayType array = vtkm::cont::make_ArrayHandle(buffer);
// Copy the array so that the data is not destroyed when we return from
// this method.
ValueArrayType arrayCopy;
Algorithm::Copy(array, arrayCopy);
return arrayCopy;
return vtkm::cont::make_ArrayHandle(buffer, vtkm::CopyFlag::On);
}
void operator()() const

35
vtkm/cont/testing/UnitTestArrayHandleRandomUniformBits.cxx
View File

@ -15,26 +15,35 @@ void TestArrayHandleRandomUniformBits()
{
auto actual0 = vtkm::cont::ArrayHandleRandomUniformBits(10, { 0 });
// result from Random123 sample implementation of philox2x32x10
std::vector<vtkm::UInt64> expected0{ 0x6cd10df2ff1dae59, 0x5f3adb6bdcdce855, 0x3fbb6394049f6998,
0xbd592d1202a74512, 0x8a115b62c08084ef, 0x1411803b3bb7eefa,
0x7d138a2280027d0e, 0x318a7703a1da82c5, 0xdcd79c6998975579,
0x6cb1a07c91f81109 };
auto expected0 = vtkm::cont::make_ArrayHandle<vtkm::UInt64>({ 0x6cd10df2ff1dae59,
0x5f3adb6bdcdce855,
0x3fbb6394049f6998,
0xbd592d1202a74512,
0x8a115b62c08084ef,
0x1411803b3bb7eefa,
0x7d138a2280027d0e,
0x318a7703a1da82c5,
0xdcd79c6998975579,
0x6cb1a07c91f81109 });
auto result =
vtkm::cont::testing::test_equal_ArrayHandles(actual0, vtkm::cont::make_ArrayHandle(expected0));
auto result = vtkm::cont::testing::test_equal_ArrayHandles(actual0, expected0);
VTKM_TEST_ASSERT(result, result.GetMergedMessage());
// initialize with seed = 100, could be "iteration number" in actual use case.
auto actual100 = vtkm::cont::ArrayHandleRandomUniformBits(10, { 100 });
// result from Random123 sample implementation of philox2x32x10
std::vector<vtkm::UInt64> expected100{
0xbd35360836122ea3, 0xe033b74acce7aa5f, 0xc0fbb65cba93ecd7, 0xe3fee2812b77e480,
0x92e5c7d563767971, 0xd99e952fb054fc19, 0xb8f2adc12094ad29, 0xb7dcb35fea8c27ac,
0x9c7b779e88270c45, 0x7325b123dc32e01d,
};
auto result100 = vtkm::cont::testing::test_equal_ArrayHandles(
actual100, vtkm::cont::make_ArrayHandle(expected100));
auto expected100 = vtkm::cont::make_ArrayHandle<vtkm::UInt64>({ 0xbd35360836122ea3,
0xe033b74acce7aa5f,
0xc0fbb65cba93ecd7,
0xe3fee2812b77e480,
0x92e5c7d563767971,
0xd99e952fb054fc19,
0xb8f2adc12094ad29,
0xb7dcb35fea8c27ac,
0x9c7b779e88270c45,
0x7325b123dc32e01d });
auto result100 = vtkm::cont::testing::test_equal_ArrayHandles(actual100, expected100);
VTKM_TEST_ASSERT(result, result.GetMergedMessage());
}

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

@ -44,7 +44,7 @@ void TestArrayHandleReverseRead()
void TestArrayHandleReverseWrite()
{
std::vector<vtkm::Id> ids(ARRAY_SIZE, 0);
vtkm::cont::ArrayHandle<vtkm::Id> handle = vtkm::cont::make_ArrayHandle(ids);
vtkm::cont::ArrayHandle<vtkm::Id> handle = vtkm::cont::make_ArrayHandle(ids, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> reverse =
vtkm::cont::make_ArrayHandleReverse(handle);
@ -63,10 +63,10 @@ void TestArrayHandleReverseWrite()
void TestArrayHandleReverseScanInclusiveByKey()
{
vtkm::Id ids[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vtkm::Id seg[] = { 0, 0, 0, 0, 1, 1, 2, 3, 3, 4 };
vtkm::cont::ArrayHandle<vtkm::Id> values = vtkm::cont::make_ArrayHandle(ids, 10);
vtkm::cont::ArrayHandle<vtkm::Id> keys = vtkm::cont::make_ArrayHandle(seg, 10);
vtkm::cont::ArrayHandle<vtkm::Id> values =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
vtkm::cont::ArrayHandle<vtkm::Id> keys =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 0, 1, 1, 2, 3, 3, 4 });
vtkm::cont::ArrayHandle<vtkm::Id> output;
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> reversed =
@ -75,9 +75,9 @@ void TestArrayHandleReverseScanInclusiveByKey()
using Algorithm = vtkm::cont::DeviceAdapterAlgorithm<vtkm::cont::DeviceAdapterTagSerial>;
Algorithm::ScanInclusiveByKey(keys, values, reversed);
vtkm::Id expected[] = { 0, 1, 3, 6, 4, 9, 6, 7, 15, 9 };
vtkm::cont::ArrayHandleReverse<vtkm::cont::ArrayHandle<vtkm::Id>> expected_reversed =
vtkm::cont::make_ArrayHandleReverse(vtkm::cont::make_ArrayHandle(expected, 10));
vtkm::cont::make_ArrayHandleReverse(
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 3, 6, 4, 9, 6, 7, 15, 9 }));
auto outputPortal = output.ReadPortal();
auto reversePortal = expected_reversed.ReadPortal();
for (int i = 0; i < 10; i++)

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

@ -156,7 +156,8 @@ struct TemplatedTests
T* end = begin + ARRAY_SIZE;
const T* cbegin = begin;
const T* cend = end;
vtkm::cont::ArrayHandle<T> arrayHandle = vtkm::cont::make_ArrayHandle(begin, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> arrayHandle =
vtkm::cont::make_ArrayHandle(begin, ARRAY_SIZE, vtkm::CopyFlag::Off);
std::cout
<< " Testing ArrayPortalToIterators(ArrayPortalFromIterators) gets back simple iterator."

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

@ -45,10 +45,11 @@ vtkm::Id ArrayLength(const T (&)[Length])
vtkm::cont::CellSetExplicit<> MakeTestCellSet1()
{
vtkm::cont::CellSetExplicit<> cs;
cs.Fill(numberOfPoints,
vtkm::cont::make_ArrayHandle(g_shapes, ArrayLength(g_shapes)),
vtkm::cont::make_ArrayHandle(g_connectivity, ArrayLength(g_connectivity)),
vtkm::cont::make_ArrayHandle(g_offsets, ArrayLength(g_offsets)));
cs.Fill(
numberOfPoints,
vtkm::cont::make_ArrayHandle(g_shapes, ArrayLength(g_shapes), vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(g_connectivity, ArrayLength(g_connectivity), vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(g_offsets, ArrayLength(g_offsets), vtkm::CopyFlag::Off));
return cs;
}
@ -57,9 +58,10 @@ vtkm::cont::CellSetExplicit<> MakeTestCellSet2()
{
vtkm::cont::CellSetExplicit<> cs;
cs.Fill(numberOfPoints,
vtkm::cont::make_ArrayHandle(g_shapes2, ArrayLength(g_shapes2)),
vtkm::cont::make_ArrayHandle(g_connectivity2, ArrayLength(g_connectivity2)),
vtkm::cont::make_ArrayHandle(g_offsets2, ArrayLength(g_offsets2)));
vtkm::cont::make_ArrayHandle(g_shapes2, ArrayLength(g_shapes2), vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(
g_connectivity2, ArrayLength(g_connectivity2), vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(g_offsets2, ArrayLength(g_offsets2), vtkm::CopyFlag::Off));
return cs;
}

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

@ -129,14 +129,14 @@ int TestCellSetExtrude()
// verify that a constant value point field can be accessed
std::vector<float> pvalues(static_cast<size_t>(coords.GetNumberOfValues()), 42.0f);
vtkm::cont::Field pfield(
"pfield", vtkm::cont::Field::Association::POINTS, vtkm::cont::make_ArrayHandle(pvalues));
vtkm::cont::Field pfield = vtkm::cont::make_Field(
"pfield", vtkm::cont::Field::Association::POINTS, pvalues, vtkm::CopyFlag::Off);
dataset.AddField(pfield);
// verify that a constant cell value can be accessed
std::vector<float> cvalues(static_cast<size_t>(cells.GetNumberOfCells()), 42.0f);
vtkm::cont::Field cfield =
vtkm::cont::make_FieldCell("cfield", vtkm::cont::make_ArrayHandle(cvalues));
vtkm::cont::Field cfield = vtkm::cont::make_Field(
"cfield", vtkm::cont::Field::Association::CELL_SET, cvalues, vtkm::CopyFlag::Off);
dataset.AddField(cfield);
vtkm::filter::PointAverage avg;

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

@ -83,9 +83,7 @@ std::vector<T> createVec(std::size_t n, const T* data)
template <typename T>
vtkm::cont::ArrayHandle<T> createAH(std::size_t n, const T* data)
{
vtkm::cont::ArrayHandle<T> arr;
DFA::Copy(vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n)), arr);
return arr;
return vtkm::cont::make_ArrayHandle(data, static_cast<vtkm::Id>(n), vtkm::CopyFlag::On);
}
template <typename T>
@ -128,9 +126,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
}
dataSet = dsb.Create(xvals, yvals, zvals, shapevals, indicesvals, connvals);
vtkm::cont::ArrayHandle<T> P, C;
DFA::Copy(vtkm::cont::make_ArrayHandle(varP), P);
DFA::Copy(vtkm::cont::make_ArrayHandle(varC), C);
vtkm::cont::ArrayHandle<T> P = vtkm::cont::make_ArrayHandle(varP, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<T> C = vtkm::cont::make_ArrayHandle(varC, vtkm::CopyFlag::On);
dataSet.AddPointField("pointvar", P);
dataSet.AddCellField("cellvar", C);
return dataSet;
@ -151,8 +148,8 @@ vtkm::cont::DataSet CreateDataSetArr(bool useSeparatedCoords,
{
varC[i][0] = static_cast<T>(f * 1.1f);
}
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> pts;
DFA::Copy(vtkm::cont::make_ArrayHandle(tmp), pts);
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> pts =
vtkm::cont::make_ArrayHandle(tmp, vtkm::CopyFlag::On);
dataSet = dsb.Create(
pts, createAH(numCells, shape), createAH(numCells, indices), createAH(numConn, conn));
dataSet.AddPointField("pointvar", varP);

27
vtkm/cont/testing/UnitTestDataSetBuilderRectilinear.cxx
View File

@ -121,7 +121,6 @@ void RectilinearTests()
const vtkm::Id NUM_FILL_METHODS = 5;
vtkm::cont::DataSetBuilderRectilinear dataSetBuilder;
vtkm::cont::DataSet dataSet;
std::uniform_int_distribution<vtkm::Id> randomDim(1, MAX_DIM_SIZE);
std::uniform_int_distribution<vtkm::IdComponent> randomFill(0, NUM_FILL_METHODS - 1);
@ -130,6 +129,8 @@ void RectilinearTests()
{
std::cout << "Trial " << trial << std::endl;
vtkm::cont::DataSet dataSet;
vtkm::Id3 dimensions(
randomDim(g_RandomGenerator), randomDim(g_RandomGenerator), randomDim(g_RandomGenerator));
std::cout << "Dimensions: " << dimensions << std::endl;
@ -216,10 +217,11 @@ void RectilinearTests()
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP2D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC2D));
dataSet =
dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(yCoordinates, vtkm::CopyFlag::Off));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP2D, vtkm::CopyFlag::Off));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC2D, vtkm::CopyFlag::Off));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
}
@ -259,16 +261,17 @@ void RectilinearTests()
&xCoordinates.front(),
&yCoordinates.front(),
&zCoordinates.front());
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D, vtkm::CopyFlag::Off));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D, vtkm::CopyFlag::Off));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
std::cout << " Create with ArrayHandle" << std::endl;
dataSet = dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates),
vtkm::cont::make_ArrayHandle(yCoordinates),
vtkm::cont::make_ArrayHandle(zCoordinates));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D));
dataSet =
dataSetBuilder.Create(vtkm::cont::make_ArrayHandle(xCoordinates, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(yCoordinates, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(zCoordinates, vtkm::CopyFlag::Off));
dataSet.AddPointField("pointvar", vtkm::cont::make_ArrayHandle(varP3D, vtkm::CopyFlag::Off));
dataSet.AddCellField("cellvar", vtkm::cont::make_ArrayHandle(varC3D, vtkm::CopyFlag::Off));
ValidateDataSet(dataSet, ndims, numPoints, numCells, bounds);
}
}

27
vtkm/cont/testing/UnitTestDataSetPermutation.cxx
View File

@ -86,12 +86,9 @@ void TestDataSet_Explicit()
vtkm::cont::DataSet dataSet = make_SingleTypeDataSet();
std::vector<vtkm::Id> validIds;
validIds.push_back(1); //iterate the 2nd cell 4 times
validIds.push_back(1);
validIds.push_back(1);
validIds.push_back(1);
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
//iterate the 2nd cell 4 times
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
//get the cellset single type from the dataset
vtkm::cont::CellSetSingleType<> cellSet;
@ -125,12 +122,9 @@ void TestDataSet_Structured2D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
std::vector<vtkm::Id> validIds;
validIds.push_back(1); //iterate the 2nd cell 4 times
validIds.push_back(1);
validIds.push_back(1);
validIds.push_back(1);
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
//iterate the 2nd cell 4 times
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
vtkm::cont::CellSetStructured<2> cellSet;
dataSet.GetCellSet().CopyTo(cellSet);
@ -161,12 +155,9 @@ void TestDataSet_Structured3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
std::vector<vtkm::Id> validIds;
validIds.push_back(1); //iterate the 2nd cell 4 times
validIds.push_back(1);
validIds.push_back(1);
validIds.push_back(1);
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds = vtkm::cont::make_ArrayHandle(validIds);
//iterate the 2nd cell 4 times
vtkm::cont::ArrayHandle<vtkm::Id> validCellIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 1, 1 });
vtkm::cont::CellSetStructured<3> cellSet;
dataSet.GetCellSet().CopyTo(cellSet);

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

@ -31,7 +31,7 @@ void TestParticleArrayCopy()
for (int i = 0; i < 2; i++)
{
auto particleAH = vtkm::cont::make_ArrayHandle(particles);
auto particleAH = vtkm::cont::make_ArrayHandle(particles, vtkm::CopyFlag::Off);
//Test copy position only
if (i == 0)

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

@ -206,8 +206,8 @@ struct TestArrayHandleGroupVecVariable
return offset;
});
auto array = vtkm::cont::make_ArrayHandleGroupVecVariable(RandomArrayHandle<T>::Make(size),
vtkm::cont::make_ArrayHandle(comps));
auto array = vtkm::cont::make_ArrayHandleGroupVecVariable(
RandomArrayHandle<T>::Make(size), vtkm::cont::make_ArrayHandle(comps, vtkm::CopyFlag::On));
RunTest(array);
// cannot make a VariantArrayHandle containing ArrayHandleGroupVecVariable

15
vtkm/cont/testing/UnitTestVariantArrayHandle.cxx
View File

@ -164,14 +164,10 @@ void CheckArrayVariant(const vtkm::cont::VariantArrayHandleBase<TypeList>& array
template <typename T>
vtkm::cont::VariantArrayHandle CreateArrayVariant(T)
{
// Declared static to prevent going out of scope.
static T buffer[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
buffer[index] = TestValue(index, T());
}
return vtkm::cont::VariantArrayHandle(vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE));
vtkm::cont::ArrayHandle<T> array;
array.Allocate(ARRAY_SIZE);
SetPortal(array.WritePortal());
return vtkm::cont::VariantArrayHandle(array);
}
template <typename ArrayHandleType>
@ -415,7 +411,8 @@ void TryCastToArrayHandle()
buffer[index] = TestValue(index, vtkm::Id());
}
vtkm::cont::ArrayHandle<vtkm::Id> array = vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE);
vtkm::cont::ArrayHandle<vtkm::Id> array =
vtkm::cont::make_ArrayHandle(buffer, ARRAY_SIZE, vtkm::CopyFlag::On);
TryCastToArrayHandle(array);
std::cout << " Cast array handle." << std::endl;

4
vtkm/filter/testing/UnitTestCrossProductFilter.cxx
View File

@ -129,8 +129,8 @@ void TestCrossProduct()
createVectors(static_cast<std::size_t>(nVerts), i, vecs1, vecs2);
vtkm::cont::ArrayHandle<vtkm::Vec3f> field1, field2;
field1 = vtkm::cont::make_ArrayHandle(vecs1);
field2 = vtkm::cont::make_ArrayHandle(vecs2);
field1 = vtkm::cont::make_ArrayHandle(vecs1, vtkm::CopyFlag::On);
field2 = vtkm::cont::make_ArrayHandle(vecs2, vtkm::CopyFlag::On);
dataSet.AddPointField("vec1", field1);
dataSet.AddPointField("vec2", field2);

4
vtkm/filter/testing/UnitTestDotProductFilter.cxx
View File

@ -118,8 +118,8 @@ void TestDotProduct()
createVectors(static_cast<std::size_t>(nVerts), i, vecs1, vecs2);
vtkm::cont::ArrayHandle<vtkm::Vec3f> field1, field2;
field1 = vtkm::cont::make_ArrayHandle(vecs1);
field2 = vtkm::cont::make_ArrayHandle(vecs2);
field1 = vtkm::cont::make_ArrayHandle(vecs1, vtkm::CopyFlag::On);
field2 = vtkm::cont::make_ArrayHandle(vecs2, vtkm::CopyFlag::On);
dataSet.AddPointField("vec1", field1);
dataSet.AddPointField("vec2", field2);

10
vtkm/filter/testing/UnitTestFieldMetadata.cxx
View File

@ -41,8 +41,9 @@ void TestFieldTypesPoint()
VTKM_TEST_ASSERT(helperMD.IsCellField() == false, "point can't be a cell field");
//verify the field helper works properly
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
auto field = vtkm::cont::make_Field("pointvar", vtkm::cont::Field::Association::POINTS, vars, 6);
auto field = vtkm::cont::make_FieldPoint(
"pointvar",
vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }));
vtkm::filter::FieldMetadata makeMDFromField(field);
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == true, "point should be a point field");
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == false, "point can't be a cell field");
@ -57,8 +58,9 @@ void TestFieldTypesCell()
VTKM_TEST_ASSERT(helperMD.IsCellField() == true, "cell should be a cell field");
//verify the field helper works properly
vtkm::Float32 vars[6] = { 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f };
auto field = vtkm::cont::make_FieldCell("pointvar", vtkm::cont::make_ArrayHandle(vars, 6));
auto field = vtkm::cont::make_FieldCell(
"pointvar",
vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 10.1f, 20.1f, 30.1f, 40.1f, 50.1f, 60.1f }));
vtkm::filter::FieldMetadata makeMDFromField(field);
VTKM_TEST_ASSERT(makeMDFromField.IsPointField() == false, "cell can't be a point field");
VTKM_TEST_ASSERT(makeMDFromField.IsCellField() == true, "cell should be a cell field");

6
vtkm/filter/testing/UnitTestGradientUniform.cxx
View File

@ -60,7 +60,8 @@ void TestCellGradientUniform3DWithVectorField()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
dataSet.AddPointField("vec_pointvar", input);
//we need to add Vec3 array to the dataset
@ -118,7 +119,8 @@ void TestPointGradientUniform3DWithVectorField()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
dataSet.AddPointField("vec_pointvar", input);
//we need to add Vec3 array to the dataset

18
vtkm/filter/testing/UnitTestLagrangianStructuresFilter.cxx
View File

@ -327,9 +327,12 @@ void Test2DLCS()
auxiliary::PopulateData(fieldVec, visitVec, diffVec, auxiliary::Option::_2D);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle =
vtkm::cont::make_ArrayHandle(diffVec, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle =
vtkm::cont::make_ArrayHandle(visitVec, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle =
vtkm::cont::make_ArrayHandle(fieldVec, vtkm::CopyFlag::On);
inputData.AddPointField("velocity", fieldHandle);
vtkm::filter::LagrangianStructures lagrangianStructures;
@ -363,9 +366,12 @@ void Test3DLCS()
auxiliary::PopulateData(fieldVec, visitVec, diffVec, auxiliary::Option::_3D);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle = vtkm::cont::make_ArrayHandle(diffVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle = vtkm::cont::make_ArrayHandle(visitVec);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle = vtkm::cont::make_ArrayHandle(fieldVec);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> diffHandle =
vtkm::cont::make_ArrayHandle(diffVec, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::FloatDefault> visitHandle =
vtkm::cont::make_ArrayHandle(visitVec, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldHandle =
vtkm::cont::make_ArrayHandle(fieldVec, vtkm::CopyFlag::On);
inputData.AddPointField("velocity", fieldHandle);
vtkm::filter::LagrangianStructures lagrangianStructures;

13
vtkm/filter/testing/UnitTestParticleAdvectionFilter.cxx
View File

@ -37,13 +37,10 @@ void TestBasic()
const vtkm::Vec3f vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
std::vector<vtkm::Massless> seeds(3);
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
seedArray = vtkm::cont::make_ArrayHandle(seeds);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::ParticleAdvection particleAdvection;
@ -91,7 +88,7 @@ void TestFile(const std::string& fname,
std::vector<vtkm::Massless> seeds;
for (vtkm::Id i = 0; i < numPoints; i++)
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On);
vtkm::filter::ParticleAdvection particleAdvection;
particleAdvection.SetStepSize(stepSize);

13
vtkm/filter/testing/UnitTestStreamSurfaceFilter.cxx
View File

@ -38,14 +38,11 @@ void TestStreamSurface()
const vtkm::Vec3f vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
std::vector<vtkm::Massless> seeds(4);
seeds[0] = vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0);
seeds[1] = vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1);
seeds[2] = vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2);
seeds[3] = vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3);
seedArray = vtkm::cont::make_ArrayHandle(seeds);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.1f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.1f, 2.0f, .1f), 1),
vtkm::Massless(vtkm::Vec3f(.1f, 3.0f, .3f), 2),
vtkm::Massless(vtkm::Vec3f(.1f, 3.5f, .2f), 3) });
vtkm::filter::StreamSurface streamSrf;

24
vtkm/filter/testing/UnitTestStreamlineFilter.cxx
View File

@ -38,13 +38,10 @@ void TestStreamline()
const vtkm::Vec3f vecX(1, 0, 0);
vtkm::cont::DataSet ds = CreateDataSet(dims, vecX);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
std::vector<vtkm::Massless> seeds(3);
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
seedArray = vtkm::cont::make_ArrayHandle(seeds);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Streamline streamline;
@ -75,13 +72,10 @@ void TestPathline()
vtkm::cont::DataSet ds1 = CreateDataSet(dims, vecX);
vtkm::cont::DataSet ds2 = CreateDataSet(dims, vecY);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray;
std::vector<vtkm::Massless> seeds(3);
seeds[0] = vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0);
seeds[1] = vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1);
seeds[2] = vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2);
seedArray = vtkm::cont::make_ArrayHandle(seeds);
vtkm::cont::ArrayHandle<vtkm::Massless> seedArray =
vtkm::cont::make_ArrayHandle({ vtkm::Massless(vtkm::Vec3f(.2f, 1.0f, .2f), 0),
vtkm::Massless(vtkm::Vec3f(.2f, 2.0f, .2f), 1),
vtkm::Massless(vtkm::Vec3f(.2f, 3.0f, .2f), 2) });
vtkm::filter::Pathline pathline;
@ -129,7 +123,7 @@ void TestStreamlineFile(const std::string& fname,
std::vector<vtkm::Massless> seeds;
for (vtkm::Id i = 0; i < numPoints; i++)
seeds.push_back(vtkm::Massless(pts[static_cast<std::size_t>(i)], i));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::On);
vtkm::filter::Streamline streamline;
streamline.SetStepSize(stepSize);

3
vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx
View File

@ -33,7 +33,8 @@ void TestVectorMagnitude()
{
fvec[i] = vtkm::make_Vec(fvars[i], fvars[i], fvars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> finput = vtkm::cont::make_ArrayHandle(fvec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> finput =
vtkm::cont::make_ArrayHandle(fvec, vtkm::CopyFlag::On);
dataSet.AddPointField("double_vec_pointvar", finput);

14
vtkm/rendering/Canvas.cxx
View File

@ -540,15 +540,15 @@ bool Canvas::LoadFont() const
{
return false;
}
std::size_t numValues = textureWidth * textureHeight;
std::vector<unsigned char> alpha(numValues);
for (std::size_t i = 0; i < numValues; ++i)
vtkm::Id numValues = static_cast<vtkm::Id>(textureWidth * textureHeight);
vtkm::cont::ArrayHandle<UInt8> alpha;
alpha.Allocate(numValues);
auto alphaPortal = alpha.WritePortal();
for (vtkm::Id i = 0; i < numValues; ++i)
{
alpha[i] = rgba[i * 4 + 3];
alphaPortal.Set(i, rgba[static_cast<std::size_t>(i * 4 + 3)]);
}
vtkm::cont::ArrayHandle<vtkm::UInt8> textureHandle = vtkm::cont::make_ArrayHandle(alpha);
Internals->FontTexture =
FontTextureType(vtkm::Id(textureWidth), vtkm::Id(textureHeight), textureHandle);
Internals->FontTexture = FontTextureType(vtkm::Id(textureWidth), vtkm::Id(textureHeight), alpha);
Internals->FontTexture.SetFilterMode(TextureFilterMode::Linear);
Internals->FontTexture.SetWrapMode(TextureWrapMode::Clamp);
return true;

33
vtkm/testing/TestingAlgorithms.h
View File

@ -55,16 +55,15 @@ struct TestBinarySearch
{
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
IdArray hayStack =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
IdArray results;
std::vector<bool> expectedFound{
false, true, true, false, true, true, false, false, true, false
};
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
IdArray results;
vtkm::cont::Token token;
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,
@ -128,14 +127,13 @@ struct TestLowerBound
{
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
std::vector<vtkm::Id> expected{ 0, 0, 1, 4, 4, 6, 9, 9, 9, 11 };
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
IdArray hayStack =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
IdArray results;
std::vector<vtkm::Id> expected{ 0, 0, 1, 4, 4, 6, 9, 9, 9, 11 };
vtkm::cont::Token token;
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,
@ -187,14 +185,13 @@ struct TestUpperBound
{
using Algo = vtkm::cont::DeviceAdapterAlgorithm<Device>;
std::vector<vtkm::Id> needlesData{ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 };
std::vector<vtkm::Id> hayStackData{ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 };
std::vector<vtkm::Id> expected{ 0, 1, 4, 4, 6, 9, 9, 9, 11, 11 };
IdArray needles = vtkm::cont::make_ArrayHandle(needlesData);
IdArray hayStack = vtkm::cont::make_ArrayHandle(hayStackData);
IdArray needles = vtkm::cont::make_ArrayHandle<vtkm::Id>({ -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
IdArray hayStack =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ -3, -2, -2, -2, 0, 0, 1, 1, 1, 4, 4 });
IdArray results;
std::vector<vtkm::Id> expected{ 0, 1, 4, 4, 6, 9, 9, 9, 11, 11 };
vtkm::cont::Token token;
using Functor = Impl<typename IdArray::ExecutionTypes<Device>::PortalConst,

22
vtkm/worklet/StreamLineUniformGrid.h
View File

@ -334,18 +334,20 @@ public:
InDataSet.GetField("vecData").GetData().CopyTo(fieldArray);
// Generate random seeds for starting streamlines
std::vector<vtkm::Vec<FieldType, 3>> seeds;
for (vtkm::Id i = 0; i < numSeeds; i++)
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray;
seedPosArray.Allocate(numSeeds);
{
vtkm::Vec<FieldType, 3> seed;
seed[0] = static_cast<FieldType>(rand() % vdims[0]);
seed[1] = static_cast<FieldType>(rand() % vdims[1]);
seed[2] = static_cast<FieldType>(rand() % vdims[2]);
seeds.push_back(seed);
auto seedPosPortal = seedPosArray.WritePortal();
for (vtkm::Id i = 0; i < numSeeds; i++)
{
vtkm::Vec<FieldType, 3> seed;
seed[0] = static_cast<FieldType>(rand() % vdims[0]);
seed[1] = static_cast<FieldType>(rand() % vdims[1]);
seed[2] = static_cast<FieldType>(rand() % vdims[2]);
seedPosPortal.Set(i, seed);
}
}
vtkm::cont::ArrayHandle<vtkm::Vec<FieldType, 3>> seedPosArray =
vtkm::cont::make_ArrayHandle(&seeds[0], numSeeds);
vtkm::cont::ArrayHandleCounting<vtkm::Id> seedIdArray(0, 1, numSeeds);
vtkm::cont::ArrayHandleIndex seedIdArray(numSeeds);
// Number of streams * number of steps * [forward, backward]
vtkm::Id numCells = numSeeds * 2;

6
vtkm/worklet/VertexClustering.h
View File

@ -111,10 +111,8 @@ template <typename T, vtkm::IdComponent N>
vtkm::cont::ArrayHandle<T> copyFromVec(vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> const& other)
{
const T* vmem = reinterpret_cast<const T*>(&*other.ReadPortal().GetIteratorBegin());
vtkm::cont::ArrayHandle<T> mem =
vtkm::cont::make_ArrayHandle(vmem, other.GetNumberOfValues() * N);
vtkm::cont::ArrayHandle<T> result;
vtkm::cont::ArrayCopy(mem, result);
vtkm::cont::ArrayHandle<T> result =
vtkm::cont::make_ArrayHandle(vmem, other.GetNumberOfValues() * N, vtkm::CopyFlag::On);
return result;
}

10
vtkm/worklet/clip/ClipTables.h
View File

@ -2522,10 +2522,12 @@ public:
};
ClipTables()
: ClipTablesDataArray(vtkm::cont::make_ArrayHandle(ClipTablesData, CLIP_TABLES_DATA_SIZE))
, ClipTablesIndicesArray(
vtkm::cont::make_ArrayHandle(ClipTablesIndices, CLIP_TABLES_INDICES_SIZE))
, CellEdgesArray(vtkm::cont::make_ArrayHandle(CellEdges, CELL_EDGES_SIZE))
: ClipTablesDataArray(
vtkm::cont::make_ArrayHandle(ClipTablesData, CLIP_TABLES_DATA_SIZE, vtkm::CopyFlag::Off))
, ClipTablesIndicesArray(vtkm::cont::make_ArrayHandle(ClipTablesIndices,
CLIP_TABLES_INDICES_SIZE,
vtkm::CopyFlag::Off))
, CellEdgesArray(vtkm::cont::make_ArrayHandle(CellEdges, CELL_EDGES_SIZE, vtkm::CopyFlag::Off))
{
}

27
vtkm/worklet/contour/MarchingCellTables.h
View File

@ -506,13 +506,16 @@ public:
};
CellClassifyTable()
: NumVerticesPerCellArray(
vtkm::cont::make_ArrayHandle(NumVerticesPerCellTable, vtkm::NUMBER_OF_CELL_SHAPES))
, NumTrianglesTableOffsetArray(
vtkm::cont::make_ArrayHandle(NumTrianglesTableOffset, vtkm::NUMBER_OF_CELL_SHAPES))
: NumVerticesPerCellArray(vtkm::cont::make_ArrayHandle(NumVerticesPerCellTable,
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, NumTrianglesTableOffsetArray(vtkm::cont::make_ArrayHandle(NumTrianglesTableOffset,
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, NumTrianglesTableArray(
vtkm::cont::make_ArrayHandle(NumTrianglesTable,
sizeof(NumTrianglesTable) / sizeof(NumTrianglesTable[0])))
sizeof(NumTrianglesTable) / sizeof(NumTrianglesTable[0]),
vtkm::CopyFlag::Off))
{
}
@ -603,17 +606,21 @@ public:
}
TriangleGenerationTable()
: EdgeTableArray(
vtkm::cont::make_ArrayHandle(EdgeTable, sizeof(EdgeTable) / sizeof(EdgeTable[0])))
: EdgeTableArray(vtkm::cont::make_ArrayHandle(EdgeTable,
sizeof(EdgeTable) / sizeof(EdgeTable[0]),
vtkm::CopyFlag::Off))
, EdgeTableOffsetArray(
vtkm::cont::make_ArrayHandle(EdgeTableOffset,
sizeof(EdgeTableOffset) / sizeof(EdgeTableOffset[0])))
sizeof(EdgeTableOffset) / sizeof(EdgeTableOffset[0]),
vtkm::CopyFlag::Off))
, TriangleTableArray(
vtkm::cont::make_ArrayHandle(TriangleTable,
sizeof(TriangleTable) / sizeof(TriangleTable[0])))
sizeof(TriangleTable) / sizeof(TriangleTable[0]),
vtkm::CopyFlag::Off))
, TriangleTableOffsetArray(
vtkm::cont::make_ArrayHandle(TriangleTableOffset,
sizeof(TriangleTableOffset) / sizeof(TriangleTableOffset[0])))
sizeof(TriangleTableOffset) / sizeof(TriangleTableOffset[0]),
vtkm::CopyFlag::Off))
{
}

3
vtkm/worklet/contour/MarchingCells.h
View File

@ -626,7 +626,8 @@ vtkm::cont::CellSetSingleType<> execute(
// Setup the invoker
vtkm::cont::Invoker invoker;
vtkm::cont::ArrayHandle<ValueType> isoValuesHandle = vtkm::cont::make_ArrayHandle(isovalues);
vtkm::cont::ArrayHandle<ValueType> isoValuesHandle =
vtkm::cont::make_ArrayHandle(isovalues, vtkm::CopyFlag::Off);
// Call the ClassifyCell functor to compute the Marching Cubes case numbers
// for each cell, and the number of vertices to be generated

2
vtkm/worklet/contourtree/ContourTree.h
View File

@ -903,7 +903,7 @@ void ContourTree<T, StorageType>::CollectSaddlePeak(
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> tempArray =
vtkm::cont::make_ArrayHandle(superarcVector);
vtkm::cont::make_ArrayHandle(superarcVector, vtkm::CopyFlag::Off);
// now sort it
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());

8
vtkm/worklet/contourtree/Mesh3D_DEM_Triangulation.h
View File

@ -149,10 +149,10 @@ Mesh3D_DEM_Triangulation<T, StorageType>::Mesh3D_DEM_Triangulation(
for (vtkm::Id shifter = NumVertices; shifter > 0; shifter >>= 1)
nLogSteps++;
neighbourOffsets3D =
vtkm::cont::make_ArrayHandle(vtkm::worklet::contourtree::neighbourOffsets3D, 42);
linkComponentCaseTable3D =
vtkm::cont::make_ArrayHandle(vtkm::worklet::contourtree::linkComponentCaseTable3D, 16384);
neighbourOffsets3D = vtkm::cont::make_ArrayHandle(
vtkm::worklet::contourtree::neighbourOffsets3D, 42, vtkm::CopyFlag::Off);
linkComponentCaseTable3D = vtkm::cont::make_ArrayHandle(
vtkm::worklet::contourtree::linkComponentCaseTable3D, 16384, vtkm::CopyFlag::Off);
}
// sets outgoing paths for saddles

10
vtkm/worklet/contourtree_augmented/ProcessContourTree.h
View File

@ -146,9 +146,8 @@ public:
// now sort it
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
EdgePairArray tempArray = vtkm::cont::make_ArrayHandle(arcSorter);
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());
vtkm::cont::ArrayCopy(tempArray, sortedArcs);
sortedArcs = vtkm::cont::make_ArrayHandle(arcSorter, vtkm::CopyFlag::On);
vtkm::cont::Algorithm::Sort(sortedArcs, SaddlePeakSort());
} // CollectSortedArcs
// collect the sorted superarcs
@ -202,11 +201,10 @@ public:
} // per vertex
// Setting saddlePeak reference to the make_ArrayHandle directly does not work
EdgePairArray tempArray = vtkm::cont::make_ArrayHandle(superarcSorter);
saddlePeak = vtkm::cont::make_ArrayHandle(superarcSorter, vtkm::CopyFlag::On);
// now sort it
vtkm::cont::Algorithm::Sort(tempArray, SaddlePeakSort());
vtkm::cont::ArrayCopy(tempArray, saddlePeak);
vtkm::cont::Algorithm::Sort(saddlePeak, SaddlePeakSort());
} // CollectSortedSuperarcs()
// routine to compute the volume for each hyperarc and superarc

6
vtkm/worklet/contourtree_augmented/mesh_dem_meshtypes/Freudenthal_2D_Triangulation.h
View File

@ -107,8 +107,10 @@ Mesh_DEM_Triangulation_2D_Freudenthal<T, StorageType>::Mesh_DEM_Triangulation_2D
: Mesh_DEM_Triangulation_2D<T, StorageType>(ncols, nrows)
{
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
m2d_freudenthal::EdgeBoundaryDetectionMasks, m2d_freudenthal::N_INCIDENT_EDGES);
this->EdgeBoundaryDetectionMasks =
vtkm::cont::make_ArrayHandle(m2d_freudenthal::EdgeBoundaryDetectionMasks,
m2d_freudenthal::N_INCIDENT_EDGES,
vtkm::CopyFlag::Off);
}
template <typename T, typename StorageType>

14
vtkm/worklet/contourtree_augmented/mesh_dem_meshtypes/Freudenthal_3D_Triangulation.h
View File

@ -114,12 +114,16 @@ Mesh_DEM_Triangulation_3D_Freudenthal<T, StorageType>::Mesh_DEM_Triangulation_3D
{
// Initialize the case tables in vtkm
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
m3d_freudenthal::EdgeBoundaryDetectionMasks, m3d_freudenthal::N_INCIDENT_EDGES);
this->EdgeBoundaryDetectionMasks =
vtkm::cont::make_ArrayHandle(m3d_freudenthal::EdgeBoundaryDetectionMasks,
m3d_freudenthal::N_INCIDENT_EDGES,
vtkm::CopyFlag::Off);
this->NeighbourOffsets = vtkm::cont::make_ArrayHandleGroupVec<3>(vtkm::cont::make_ArrayHandle(
m3d_freudenthal::NeighbourOffsets, m3d_freudenthal::N_INCIDENT_EDGES * 3));
this->LinkComponentCaseTable = vtkm::cont::make_ArrayHandle(
m3d_freudenthal::LinkComponentCaseTable, m3d_freudenthal::LINK_COMPONENT_CASES);
m3d_freudenthal::NeighbourOffsets, m3d_freudenthal::N_INCIDENT_EDGES * 3, vtkm::CopyFlag::Off));
this->LinkComponentCaseTable =
vtkm::cont::make_ArrayHandle(m3d_freudenthal::LinkComponentCaseTable,
m3d_freudenthal::LINK_COMPONENT_CASES,
vtkm::CopyFlag::Off);
}

27
vtkm/worklet/contourtree_augmented/mesh_dem_meshtypes/MarchingCubes_3D_Triangulation.h
View File

@ -118,37 +118,42 @@ Mesh_DEM_Triangulation_3D_MarchingCubes<T, StorageType>::Mesh_DEM_Triangulation_
{
// Initialize the case tables in vtkm
this->EdgeBoundaryDetectionMasks = vtkm::cont::make_ArrayHandle(
m3d_marchingcubes::EdgeBoundaryDetectionMasks, m3d_marchingcubes::N_ALL_NEIGHBOURS);
this->EdgeBoundaryDetectionMasks =
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::EdgeBoundaryDetectionMasks,
m3d_marchingcubes::N_ALL_NEIGHBOURS,
vtkm::CopyFlag::Off);
this->CubeVertexPermutations = vtkm::cont::make_ArrayHandleGroupVec<
m3d_marchingcubes::
CubeVertexPermutations_PermVecLength>( // create 2D array of vectors of lenghts ...PermVecLength
vtkm::cont::make_ArrayHandle(
m3d_marchingcubes::CubeVertexPermutations, // the array to convert
m3d_marchingcubes::CubeVertexPermutations_NumPermutations *
m3d_marchingcubes::CubeVertexPermutations_PermVecLength // total number of elements
));
m3d_marchingcubes::CubeVertexPermutations_PermVecLength, // total number of elements
vtkm::CopyFlag::Off));
this->LinkVertexConnectionsSix = vtkm::cont::make_ArrayHandleGroupVec<
m3d_marchingcubes::
VertexConnections_VecLength>( // create 2D array of vectors o lenght ...VecLength
vtkm::cont::make_ArrayHandle(
m3d_marchingcubes::LinkVertexConnectionsSix, // the array to convert
m3d_marchingcubes::LinkVertexConnectionsSix_NumPairs *
m3d_marchingcubes::VertexConnections_VecLength // total number of elements
));
m3d_marchingcubes::VertexConnections_VecLength, // total number of elements
vtkm::CopyFlag::Off));
this->LinkVertexConnectionsEighteen = vtkm::cont::make_ArrayHandleGroupVec<
m3d_marchingcubes::
VertexConnections_VecLength>( // create 2D array of vectors o lenght ...VecLength
vtkm::cont::make_ArrayHandle(
m3d_marchingcubes::LinkVertexConnectionsEighteen, // the array to convert
m3d_marchingcubes::LinkVertexConnectionsEighteen_NumPairs *
m3d_marchingcubes::VertexConnections_VecLength // total number of elements
));
this->InCubeConnectionsSix = vtkm::cont::make_ArrayHandle(
m3d_marchingcubes::InCubeConnectionsSix, m3d_marchingcubes::InCubeConnectionsSix_NumElements);
m3d_marchingcubes::VertexConnections_VecLength, // total number of elements
vtkm::CopyFlag::Off));
this->InCubeConnectionsSix =
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::InCubeConnectionsSix,
m3d_marchingcubes::InCubeConnectionsSix_NumElements,
vtkm::CopyFlag::Off);
this->InCubeConnectionsEighteen =
vtkm::cont::make_ArrayHandle(m3d_marchingcubes::InCubeConnectionsEighteen,
m3d_marchingcubes::InCubeConnectionsEighteen_NumElements);
m3d_marchingcubes::InCubeConnectionsEighteen_NumElements,
vtkm::CopyFlag::Off);
}
template <typename T, typename StorageType>

12
vtkm/worklet/contourtree_augmented/processcontourtree/EulerTour.h
View File

@ -115,14 +115,10 @@ public:
//cont::ArrayHandle<Id> first;
cont::ArrayHandle<Id> next;
vtkm::cont::ArrayCopy(
vtkm::cont::make_ArrayHandle(std::vector<Id>(
static_cast<unsigned long>(superarcs.GetNumberOfValues()), NO_SUCH_ELEMENT)),
first);
vtkm::cont::ArrayCopy(
vtkm::cont::make_ArrayHandle(
std::vector<Id>(static_cast<unsigned long>(edges.GetNumberOfValues()), NO_SUCH_ELEMENT)),
next);
first = vtkm::cont::make_ArrayHandleMove(
std::vector<Id>(static_cast<unsigned long>(superarcs.GetNumberOfValues()), NO_SUCH_ELEMENT));
next = vtkm::cont::make_ArrayHandleMove(
std::vector<Id>(static_cast<unsigned long>(edges.GetNumberOfValues()), NO_SUCH_ELEMENT));
//
// Compute First and Next arrays that are needed to compute the euler tour linked list

21
vtkm/worklet/internal/TriangulateTables.h
View File

@ -181,10 +181,14 @@ public:
VTKM_CONT
TriangulateTables()
: Counts(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleCountData,
vtkm::NUMBER_OF_CELL_SHAPES))
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, Offsets(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleOffsetData,
vtkm::NUMBER_OF_CELL_SHAPES))
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleIndexData, vtkm::Id(9)))
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TriangleIndexData,
vtkm::Id(9),
vtkm::CopyFlag::Off))
{
}
@ -382,11 +386,14 @@ public:
VTKM_CONT
TetrahedralizeTables()
: Counts(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronCountData,
vtkm::NUMBER_OF_CELL_SHAPES))
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, Offsets(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronOffsetData,
vtkm::NUMBER_OF_CELL_SHAPES))
, Indices(
vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronIndexData, vtkm::Id(44)))
vtkm::NUMBER_OF_CELL_SHAPES,
vtkm::CopyFlag::Off))
, Indices(vtkm::cont::make_ArrayHandle(vtkm::worklet::internal::TetrahedronIndexData,
vtkm::Id(44),
vtkm::CopyFlag::Off))
{
}

3
vtkm/worklet/testing/UnitTestAverageByKey.cxx
View File

@ -60,7 +60,8 @@ void TryKeyType(KeyType)
{
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
}
vtkm::cont::ArrayHandle<KeyType> keysArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
vtkm::cont::ArrayHandle<KeyType> keysArray =
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::Off);
// Create Keys object
vtkm::cont::ArrayHandle<KeyType> sortedKeys;

6
vtkm/worklet/testing/UnitTestCellGradient.cxx
View File

@ -84,7 +84,8 @@ void TestCellGradientUniform3DWithVectorField()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
//we need to add Vec3 array to the dataset
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Vec3f_64, 3>> result;
@ -159,7 +160,8 @@ void TestCellGradientUniform3DWithVectorField2()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::Off);
vtkm::worklet::GradientOutputFields<vtkm::Vec3f_64> extraOutput;
extraOutput.SetComputeGradient(false);

5
vtkm/worklet/testing/UnitTestCellSetDualGraph.cxx
View File

@ -40,10 +40,11 @@ private:
public:
void TestTriangleMesh() const
{
std::vector<vtkm::Id> connectivity = { 0, 2, 4, 1, 3, 5, 2, 6, 4, 5, 3, 7, 2, 9, 6, 4, 6, 8 };
auto connectivity = vtkm::cont::make_ArrayHandle<vtkm::Id>(
{ 0, 2, 4, 1, 3, 5, 2, 6, 4, 5, 3, 7, 2, 9, 6, 4, 6, 8 });
vtkm::cont::CellSetSingleType<> cellSet;
cellSet.Fill(8, vtkm::CELL_SHAPE_TRIANGLE, 3, vtkm::cont::make_ArrayHandle(connectivity));
cellSet.Fill(8, vtkm::CELL_SHAPE_TRIANGLE, 3, connectivity);
vtkm::cont::ArrayHandle<vtkm::Id> numIndicesArray;
vtkm::cont::ArrayHandle<vtkm::Id> indexOffsetArray;

109
vtkm/worklet/testing/UnitTestContourTreeUniformAugmented.cxx
View File

@ -964,7 +964,7 @@ public:
37, 83, 91, 33, 41, 82, 92, 32, 42, 86, 88, 36, 38, 81, 93, 31, 43
};
vtkm::worklet::contourtree_augmented::IdArrayType expectedSortOrder =
vtkm::cont::make_ArrayHandle(expectedSortOrderArr, 125);
vtkm::cont::make_ArrayHandle(expectedSortOrderArr, 125, vtkm::CopyFlag::On);
vtkm::Id expectedSortIndicesArr[125] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
@ -976,7 +976,7 @@ public:
81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
};
vtkm::worklet::contourtree_augmented::IdArrayType expectedSortIndices =
vtkm::cont::make_ArrayHandle(expectedSortIndicesArr, 125);
vtkm::cont::make_ArrayHandle(expectedSortIndicesArr, 125, vtkm::CopyFlag::On);
//
// Join Tree Set Starts
@ -996,7 +996,7 @@ public:
meshExtremaPeaksJoinArr[i] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksJoin =
vtkm::cont::make_ArrayHandle(meshExtremaPeaksJoinArr, 125);
vtkm::cont::make_ArrayHandle(meshExtremaPeaksJoinArr, 125, vtkm::CopyFlag::On);
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsJoin;
vtkm::cont::Algorithm::Copy(vtkm::cont::ArrayHandleConstant<vtkm::Id>(0, 125),
meshExtremaPitsJoin);
@ -1019,7 +1019,8 @@ public:
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksBuildRegularChainsJoin =
vtkm::cont::make_ArrayHandle(meshExtremaPeaksBuildRegularChainsJoinArr, 125);
vtkm::cont::make_ArrayHandle(
meshExtremaPeaksBuildRegularChainsJoinArr, 125, vtkm::CopyFlag::On);
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsBuildRegularChainsJoin =
meshExtremaPitsJoin; // should remain all at 0
@ -1043,7 +1044,7 @@ public:
meshExtremaPeaksSplitArr[i] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksSplit =
vtkm::cont::make_ArrayHandle(meshExtremaPeaksSplitArr, 125);
vtkm::cont::make_ArrayHandle(meshExtremaPeaksSplitArr, 125, vtkm::CopyFlag::On);
vtkm::Id meshExtremaPitsSplitArr[125] = {
0, 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@ -1058,7 +1059,7 @@ public:
meshExtremaPitsSplitArr[98] =
meshExtremaPitsSplitArr[97] | vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsSplit =
vtkm::cont::make_ArrayHandle(meshExtremaPitsSplitArr, 125);
vtkm::cont::make_ArrayHandle(meshExtremaPitsSplitArr, 125, vtkm::CopyFlag::On);
//
// Split Tree Build Regular chains
@ -1079,7 +1080,8 @@ public:
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPeaksBuildRegularChainsSplit =
vtkm::cont::make_ArrayHandle(meshExtremaPeaksBuildRegularChainsSplitArr, 125);
vtkm::cont::make_ArrayHandle(
meshExtremaPeaksBuildRegularChainsSplitArr, 125, vtkm::CopyFlag::On);
vtkm::Id meshExtremaPitsBuildRegularChainsSplitArr[125] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -1094,7 +1096,8 @@ public:
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType meshExtremaPitsBuildRegularChainsSplit =
vtkm::cont::make_ArrayHandle(meshExtremaPitsBuildRegularChainsSplitArr, 125);
vtkm::cont::make_ArrayHandle(
meshExtremaPitsBuildRegularChainsSplitArr, 125, vtkm::CopyFlag::On);
//
// Join Graph Initialize
@ -1103,19 +1106,19 @@ public:
vtkm::Id activeGraphJoinTreeInitGlobalIndexArr[12] = { 103, 104, 105, 106, 113, 114,
115, 116, 121, 122, 123, 124 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitGlobalIndex =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitGlobalIndexArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitGlobalIndexArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize FirstEdge
vtkm::Id activeGraphJoinTreeInitFirstEdgeArr[12] = {
0, 2, 4, 6, 8, 10, 12, 14, 16, 16, 16, 16
};
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitFirstEdge =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitFirstEdgeArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitFirstEdgeArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize Outdegree
vtkm::Id activeGraphJoinTreeInitOutdegreeArr[12] = { 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 0, 0 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitOutdegree =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitOutdegreeArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitOutdegreeArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize Hyperarcs
vtkm::Id activeGraphJoinTreeInitHyperarcsArr[12] = {
@ -1127,32 +1130,33 @@ public:
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitHyperarcs =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitHyperarcsArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitHyperarcsArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize ActiveVertices
vtkm::Id activeGraphJoinTreeInitActiveVerticesArr[12] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitActiveVertices =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveVerticesArr, 12);
vtkm::cont::make_ArrayHandle(
activeGraphJoinTreeInitActiveVerticesArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize EdgeNear
vtkm::Id activeGraphJoinTreeInitEdgeNearArr[16] = { 0, 0, 1, 1, 2, 2, 3, 3,
4, 4, 5, 5, 6, 6, 7, 7 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitEdgeNear =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeNearArr, 16);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeNearArr, 16, vtkm::CopyFlag::On);
// Active graph join graph initialize , EdgeFar
vtkm::Id activeGraphJoinTreeInitEdgeFarArr[16] = { 10, 8, 10, 9, 10, 9, 10, 8,
8, 9, 8, 9, 10, 11, 10, 11 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitEdgeFar =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeFarArr, 16);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitEdgeFarArr, 16, vtkm::CopyFlag::On);
// Active graph join graph initialize , ActiveEdges
vtkm::Id activeGraphJoinTreeInitActiveEdgesArr[16] = { 0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphJoinTreeInitActiveEdges =
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveEdgesArr, 16);
vtkm::cont::make_ArrayHandle(activeGraphJoinTreeInitActiveEdgesArr, 16, vtkm::CopyFlag::On);
//
// Split Graph Initialize
@ -1160,17 +1164,17 @@ public:
// Active graph join graph initialize GlobalIndex
vtkm::Id activeGraphSplitTreeInitGlobalIndexArr[8] = { 0, 98, 99, 100, 101, 102, 107, 108 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitGlobalIndex =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitGlobalIndexArr, 8);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitGlobalIndexArr, 8, vtkm::CopyFlag::On);
// Active graph join graph initialize FirstEdge
vtkm::Id activeGraphSplitTreeInitFirstEdgeArr[8] = { 0, 0, 0, 2, 4, 6, 8, 10 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitFirstEdge =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitFirstEdgeArr, 8);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitFirstEdgeArr, 8, vtkm::CopyFlag::On);
// Active graph join graph initialize Outdegree
vtkm::Id activeGraphSplitTreeInitOutdegreeArr[8] = { 0, 0, 2, 2, 2, 2, 2, 2 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitOutdegree =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitOutdegreeArr, 8);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitOutdegreeArr, 8, vtkm::CopyFlag::On);
// Active graph join graph initialize Hyperarcs
vtkm::Id activeGraphSplitTreeInitHyperarcsArr[8] = { 0, 1, 1, 1, 0, 0, 0, 0 };
@ -1180,27 +1184,28 @@ public:
vtkm::worklet::contourtree_augmented::TERMINAL_ELEMENT;
}
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitHyperarcs =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitHyperarcsArr, 8);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitHyperarcsArr, 8, vtkm::CopyFlag::On);
// Active graph join graph initialize ActiveVertices
vtkm::Id activeGraphSplitTreeInitActiveVerticesArr[8] = { 0, 1, 2, 3, 4, 5, 6, 7 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitActiveVertices =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveVerticesArr, 8);
vtkm::cont::make_ArrayHandle(
activeGraphSplitTreeInitActiveVerticesArr, 8, vtkm::CopyFlag::On);
// Active graph join graph initialize EdgeNear
vtkm::Id activeGraphSplitTreeInitEdgeNearArr[12] = { 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitEdgeNear =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeNearArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeNearArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize , EdgeFar
vtkm::Id activeGraphSplitTreeInitEdgeFarArr[12] = { 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitEdgeFar =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeFarArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitEdgeFarArr, 12, vtkm::CopyFlag::On);
// Active graph join graph initialize , ActiveEdges
vtkm::Id activeGraphSplitTreeInitActiveEdgesArr[12] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
vtkm::worklet::contourtree_augmented::IdArrayType activeGraphSplitTreeInitActiveEdges =
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveEdgesArr, 12);
vtkm::cont::make_ArrayHandle(activeGraphSplitTreeInitActiveEdgesArr, 12, vtkm::CopyFlag::On);
//
// JoinTree MakeMergeTree
@ -1219,7 +1224,7 @@ public:
makeJoinTreeArcsArr[0] =
makeJoinTreeArcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeArcs =
vtkm::cont::make_ArrayHandle(makeJoinTreeArcsArr, 125);
vtkm::cont::make_ArrayHandle(makeJoinTreeArcsArr, 125, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeSuperparentsArr[125] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -1229,35 +1234,35 @@ public:
0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 1, 2, 2, 1, 1, 2, 2, 3, 4, 5, 6, 3, 4, 5, 6
};
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSuperparents =
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperparentsArr, 125);
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperparentsArr, 125, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeSupernodesArr[7] = { 106, 114, 116, 121, 122, 123, 124 };
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSupernodes =
vtkm::cont::make_ArrayHandle(makeJoinTreeSupernodesArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeSupernodesArr, 7, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeSuperarcsArr[7] = { 0, 0, 0, 1, 1, 2, 2 };
makeJoinTreeSuperarcsArr[0] =
makeJoinTreeSuperarcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeSuperarcs =
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperarcsArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeSuperarcsArr, 7, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeHyperparentsArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHyperparents =
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperparentsArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperparentsArr, 7, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeHypernodesArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHypernodes =
vtkm::cont::make_ArrayHandle(makeJoinTreeHypernodesArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeHypernodesArr, 7, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeHyperarcsArr[7] = { 0, 0, 0, 1, 1, 2, 2 };
makeJoinTreeHyperarcsArr[0] =
makeJoinTreeHyperarcsArr[0] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeHyperarcs =
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperarcsArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeHyperarcsArr, 7, vtkm::CopyFlag::On);
vtkm::Id makeJoinTreeFirstSuperchildArr[7] = { 0, 1, 2, 3, 4, 5, 6 };
vtkm::worklet::contourtree_augmented::IdArrayType makeJoinTreeFirstSuperchild =
vtkm::cont::make_ArrayHandle(makeJoinTreeFirstSuperchildArr, 7);
vtkm::cont::make_ArrayHandle(makeJoinTreeFirstSuperchildArr, 7, vtkm::CopyFlag::On);
//
@ -1277,7 +1282,7 @@ public:
makeSplitTreeArcsArr[124] =
makeSplitTreeArcsArr[124] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeArcs =
vtkm::cont::make_ArrayHandle(makeSplitTreeArcsArr, 125);
vtkm::cont::make_ArrayHandle(makeSplitTreeArcsArr, 125, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeSuperparentsArr[125] = {
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@ -1287,37 +1292,37 @@ public:
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSuperparents =
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperparentsArr, 125);
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperparentsArr, 125, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeSupernodesArr[3] = { 99, 98, 0 };
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSupernodes =
vtkm::cont::make_ArrayHandle(makeSplitTreeSupernodesArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeSupernodesArr, 3, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeSuperarcsArr[3] = {
0 | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT, 0, 0
};
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeSuperarcs =
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperarcsArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeSuperarcsArr, 3, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeHyperparentsArr[3] = { 2, 1, 0 };
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHyperparents =
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperparentsArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperparentsArr, 3, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeHypernodesArr[3] = {
2, 1, 0,
};
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHypernodes =
vtkm::cont::make_ArrayHandle(makeSplitTreeHypernodesArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeHypernodesArr, 3, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeHyperarcsArr[3] = {
0, 0, 0 | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT
};
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeHyperarcs =
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperarcsArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeHyperarcsArr, 3, vtkm::CopyFlag::On);
vtkm::Id makeSplitTreeFirstSuperchildArr[3] = { 2, 1, 0 };
vtkm::worklet::contourtree_augmented::IdArrayType makeSplitTreeFirstSuperchild =
vtkm::cont::make_ArrayHandle(makeSplitTreeFirstSuperchildArr, 3);
vtkm::cont::make_ArrayHandle(makeSplitTreeFirstSuperchildArr, 3, vtkm::CopyFlag::On);
//
// Contour Tree Compute
@ -1337,7 +1342,7 @@ public:
vtkm::Id makeContourTreeSupernodesArr[10] = { 121, 122, 123, 124, 0, 98, 114, 116, 99, 106 };
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeSupernodes =
vtkm::cont::make_ArrayHandle(makeContourTreeSupernodesArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeSupernodesArr, 10, vtkm::CopyFlag::On);
vtkm::Id makeContourTreeSuperarcsArr[10] = { 6, 6, 7, 7, 8, 8, 9, 9, 9, 0 };
makeContourTreeSuperarcsArr[4] =
@ -1350,7 +1355,7 @@ public:
makeContourTreeSuperarcsArr[9] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeSuperarcs =
vtkm::cont::make_ArrayHandle(makeContourTreeSuperarcsArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeSuperarcsArr, 10, vtkm::CopyFlag::On);
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeAugmentnodes;
@ -1358,7 +1363,7 @@ public:
vtkm::Id makeContourTreeHyperparentsArr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHyperparents =
vtkm::cont::make_ArrayHandle(makeContourTreeHyperparentsArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeHyperparentsArr, 10, vtkm::CopyFlag::On);
vtkm::Id makeContourTreeWhenTransferredArr[10] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 4 };
for (vtkm::Id i = 0; i < 10; i++)
@ -1367,11 +1372,11 @@ public:
makeContourTreeWhenTransferredArr[i] | vtkm::worklet::contourtree_augmented::IS_HYPERNODE;
}
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeWhenTransferred =
vtkm::cont::make_ArrayHandle(makeContourTreeWhenTransferredArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeWhenTransferredArr, 10, vtkm::CopyFlag::On);
vtkm::Id makeContourTreeHypernodesArr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHypernodes =
vtkm::cont::make_ArrayHandle(makeContourTreeHypernodesArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeHypernodesArr, 10, vtkm::CopyFlag::On);
vtkm::Id makeContourTreeHyperarcsArr[10] = { 6, 6, 7, 7, 8, 8, 9, 9, 9, 0 };
makeContourTreeHyperarcsArr[4] =
@ -1383,7 +1388,7 @@ public:
makeContourTreeHyperarcsArr[9] =
makeContourTreeHyperarcsArr[9] | vtkm::worklet::contourtree_augmented::NO_SUCH_ELEMENT;
vtkm::worklet::contourtree_augmented::IdArrayType makeContourTreeHyperarcs =
vtkm::cont::make_ArrayHandle(makeContourTreeHyperarcsArr, 10);
vtkm::cont::make_ArrayHandle(makeContourTreeHyperarcsArr, 10, vtkm::CopyFlag::On);
vtkm::worklet::contourtree_augmented::IdArrayType makeRegularStructureNodes;
vtkm::worklet::contourtree_augmented::IdArrayType makeRegularStructureArcs;
@ -1432,7 +1437,8 @@ public:
82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 114,
113, 110, 109, 107, 116, 115, 112, 111, 108, 99, 100, 101, 102, 103, 104, 105, 106
};
makeRegularStructureNodes = vtkm::cont::make_ArrayHandle(makeRegularStructureNodesArr, 125);
makeRegularStructureNodes =
vtkm::cont::make_ArrayHandle(makeRegularStructureNodesArr, 125, vtkm::CopyFlag::On);
makeRegularStructureArcsArr = new vtkm::Id[125]{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
@ -1450,7 +1456,8 @@ public:
makeRegularStructureArcsArr[i] =
makeRegularStructureArcsArr[i] | vtkm::worklet::contourtree_augmented::IS_ASCENDING;
}
makeRegularStructureArcs = vtkm::cont::make_ArrayHandle(makeRegularStructureArcsArr, 125);
makeRegularStructureArcs =
vtkm::cont::make_ArrayHandle(makeRegularStructureArcsArr, 125, vtkm::CopyFlag::On);
makeRegularStructureSuperparentsArr =
new vtkm::Id[125]{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
@ -1460,7 +1467,7 @@ public:
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 8, 8, 8, 8, 8, 8,
8, 9, 6, 7, 6, 6, 7, 7, 6, 6, 7, 7, 0, 1, 2, 3, 0, 1, 2, 3 };
makeRegularStructureSuperparents =
vtkm::cont::make_ArrayHandle(makeRegularStructureSuperparentsArr, 125);
vtkm::cont::make_ArrayHandle(makeRegularStructureSuperparentsArr, 125, vtkm::CopyFlag::On);
makeRegularStructureSupernodes = makeContourTreeSupernodes;
makeRegularStructureSuperarcs = makeContourTreeSuperarcs;
makeRegularStructureAugmentnodes = makeContourTreeAugmentnodes;
@ -1487,7 +1494,7 @@ public:
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 106, 114, 116, 121, 122, 123, 124 };
makeRegularStructureAugmentnodes =
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentnodesArr, 107);
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentnodesArr, 107, vtkm::CopyFlag::On);
makeRegularStructureAugmentarcsArr =
new vtkm::Id[107]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
@ -1506,7 +1513,7 @@ public:
}
makeRegularStructureAugmentarcs =
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentarcsArr, 107);
vtkm::cont::make_ArrayHandle(makeRegularStructureAugmentarcsArr, 107, vtkm::CopyFlag::On);
makeRegularStructureHyperparents = makeContourTreeHyperparents;

4
vtkm/worklet/testing/UnitTestCrossProduct.cxx
View File

@ -66,8 +66,8 @@ void TestCrossProduct()
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> inputArray1, inputArray2;
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> outputArray;
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1);
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2);
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1, vtkm::CopyFlag::Off);
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2, vtkm::CopyFlag::Off);
vtkm::worklet::CrossProduct crossProductWorklet;
vtkm::worklet::DispatcherMapField<vtkm::worklet::CrossProduct> dispatcherCrossProduct(

34
vtkm/worklet/testing/UnitTestDescriptiveStatistics.cxx
View File

@ -15,8 +15,7 @@
void TestSingle()
{
std::vector<vtkm::Float32> single(1, 42);
auto single_array = vtkm::cont::make_ArrayHandle(single);
auto single_array = vtkm::cont::make_ArrayHandle<vtkm::Float32>({ 42 });
auto result = vtkm::worklet::DescriptiveStatistics::Run(single_array);
VTKM_TEST_ASSERT(test_equal(result.N(), 1));
@ -70,7 +69,7 @@ void TestStandardNormal()
std::vector<vtkm::Float32> x(1000000);
std::generate(x.begin(), x.end(), [&gen, &dis]() { return dis(gen); });
auto array = vtkm::cont::make_ArrayHandle(x);
auto array = vtkm::cont::make_ArrayHandle(x, vtkm::CopyFlag::Off);
auto result = vtkm::worklet::DescriptiveStatistics::Run(array);
// Variance should be positive
@ -84,8 +83,8 @@ void TestStandardNormal()
void TestCatastrophicCancellation()
{
// Good examples of the effect of catastrophic cancellation from Wikipedia.
std::vector<vtkm::Float64> okay{ 1e8 + 4, 1e8 + 7, 1e8 + 13, 1.0e8 + 16 };
auto arrayOK = vtkm::cont::make_ArrayHandle(okay);
auto arrayOK =
vtkm::cont::make_ArrayHandle<vtkm::Float64>({ 1e8 + 4, 1e8 + 7, 1e8 + 13, 1.0e8 + 16 });
auto resultOK = vtkm::worklet::DescriptiveStatistics::Run(arrayOK);
VTKM_TEST_ASSERT(test_equal(resultOK.N(), 4));
@ -97,8 +96,8 @@ void TestCatastrophicCancellation()
// Bad examples of the effect of catastrophic cancellation from Wikipedia.
// A naive algorithm will fail in calculating the correct variance
std::vector<vtkm::Float64> evil{ 1e9 + 4, 1e9 + 7, 1e9 + 13, 1.0e9 + 16 };
auto arrayEvil = vtkm::cont::make_ArrayHandle(evil);
auto arrayEvil =
vtkm::cont::make_ArrayHandle<vtkm::Float64>({ 1e9 + 4, 1e9 + 7, 1e9 + 13, 1.0e9 + 16 });
auto resultEvil = vtkm::worklet::DescriptiveStatistics::Run(arrayEvil);
VTKM_TEST_ASSERT(test_equal(resultEvil.N(), 4));
@ -125,7 +124,7 @@ void TestGeneGolub()
i = dis(gen);
}
auto array = vtkm::cont::make_ArrayHandle(v);
auto array = vtkm::cont::make_ArrayHandle(v, vtkm::CopyFlag::Off);
auto result = vtkm::worklet::DescriptiveStatistics::Run(array);
// Variance should be positive
@ -146,8 +145,8 @@ void TestMeanProperties()
std::transform(
x.begin(), x.end(), axpb.begin(), [](vtkm::Float32 value) { return 4.0f * value + 1000.f; });
auto x_array = vtkm::cont::make_ArrayHandle(x);
auto axpb_array = vtkm::cont::make_ArrayHandle(axpb);
auto x_array = vtkm::cont::make_ArrayHandle(x, vtkm::CopyFlag::Off);
auto axpb_array = vtkm::cont::make_ArrayHandle(axpb, vtkm::CopyFlag::Off);
auto mean_x = vtkm::worklet::DescriptiveStatistics::Run(x_array).Mean();
auto mean_axpb = vtkm::worklet::DescriptiveStatistics::Run(axpb_array).Mean();
@ -158,7 +157,7 @@ void TestMeanProperties()
std::vector<vtkm::Float32> px = x;
std::shuffle(px.begin(), px.end(), gen);
auto px_array = vtkm::cont::make_ArrayHandle(px);
auto px_array = vtkm::cont::make_ArrayHandle(px, vtkm::CopyFlag::Off);
auto mean_px = vtkm::worklet::DescriptiveStatistics::Run(px_array).Mean();
VTKM_TEST_ASSERT(test_equal(mean_x, mean_px, 0.01f));
@ -178,8 +177,8 @@ void TestVarianceProperty()
std::transform(
v.begin(), v.end(), kv.begin(), [](vtkm::Float32 value) { return 4.0f * value + 5.0f; });
auto array_v = vtkm::cont::make_ArrayHandle(v);
auto array_kv = vtkm::cont::make_ArrayHandle(kv);
auto array_v = vtkm::cont::make_ArrayHandle(v, vtkm::CopyFlag::Off);
auto array_kv = vtkm::cont::make_ArrayHandle(kv, vtkm::CopyFlag::Off);
auto result_v = vtkm::worklet::DescriptiveStatistics::Run(array_v);
auto result_kv = vtkm::worklet::DescriptiveStatistics::Run(array_kv);
auto mean_v = result_v.Mean();
@ -202,7 +201,7 @@ void TestVarianceProperty()
std::vector<vtkm::Float32> px = v;
std::shuffle(px.begin(), px.end(), gen);
auto px_array = vtkm::cont::make_ArrayHandle(px);
auto px_array = vtkm::cont::make_ArrayHandle(px, vtkm::CopyFlag::Off);
auto var_px = vtkm::worklet::DescriptiveStatistics::Run(px_array).SampleVariance();
vtkm::Float32 condition_number_v = 0;
@ -219,11 +218,8 @@ void TestVarianceProperty()
void TestMomentsByKey()
{
std::vector<vtkm::UInt32> keys{ 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 };
auto values_array =
vtkm::cont::make_ArrayHandleConstant(1.0f, static_cast<vtkm::Id>(keys.size()));
auto keys_array = vtkm::cont::make_ArrayHandle(keys);
auto keys_array = vtkm::cont::make_ArrayHandle<vtkm::UInt32>({ 0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 });
auto values_array = vtkm::cont::make_ArrayHandleConstant(1.0f, keys_array.GetNumberOfValues());
auto results = vtkm::worklet::DescriptiveStatistics::Run(keys_array, values_array);
VTKM_TEST_ASSERT(results.GetNumberOfValues() == 5);

4
vtkm/worklet/testing/UnitTestDotProduct.cxx
View File

@ -70,8 +70,8 @@ void TestDotProduct()
vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>> inputArray1, inputArray2;
vtkm::cont::ArrayHandle<T> outputArray;
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1);
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2);
inputArray1 = vtkm::cont::make_ArrayHandle(inputVecs1, vtkm::CopyFlag::Off);
inputArray2 = vtkm::cont::make_ArrayHandle(inputVecs2, vtkm::CopyFlag::Off);
vtkm::worklet::DotProduct dotProductWorklet;
vtkm::worklet::DispatcherMapField<vtkm::worklet::DotProduct> dispatcherDotProduct(

17
vtkm/worklet/testing/UnitTestExtractGeometry.cxx
View File

@ -32,9 +32,8 @@ public:
dataset.GetCellSet().CopyTo(cellSet);
// Cells to extract
const int nCells = 2;
vtkm::Id cellids[nCells] = { 1, 2 };
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 2 });
const vtkm::Id nCells = cellIds.GetNumberOfValues();
// Output data set with cell set containing extracted cells and all points
vtkm::worklet::ExtractGeometry extractGeometry;
@ -107,9 +106,9 @@ public:
dataset.GetCellSet().CopyTo(cellSet);
// Cells to extract
const int nCells = 5;
vtkm::Id cellids[nCells] = { 0, 4, 5, 10, 15 };
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
vtkm::cont::ArrayHandle<vtkm::Id> cellIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 10, 15 });
const vtkm::Id nCells = cellIds.GetNumberOfValues();
// Output data set permutation of with only extracted cells
vtkm::worklet::ExtractGeometry extractGeometry;
@ -140,9 +139,9 @@ public:
dataset.GetCellSet().CopyTo(cellSet);
// Cells to extract
const int nCells = 5;
vtkm::Id cellids[nCells] = { 0, 4, 5, 10, 15 };
vtkm::cont::ArrayHandle<vtkm::Id> cellIds = vtkm::cont::make_ArrayHandle(cellids, nCells);
vtkm::cont::ArrayHandle<vtkm::Id> cellIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 10, 15 });
const vtkm::Id nCells = cellIds.GetNumberOfValues();
// Output data set with cell set containing extracted cells and all points
vtkm::worklet::ExtractGeometry extractGeometry;

14
vtkm/worklet/testing/UnitTestExtractPoints.cxx
View File

@ -28,9 +28,8 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
// Points to extract
const int nPoints = 13;
vtkm::Id pointids[nPoints] = { 0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 50, 75, 100 };
vtkm::cont::ArrayHandle<vtkm::Id> pointIds = vtkm::cont::make_ArrayHandle(pointids, nPoints);
vtkm::cont::ArrayHandle<vtkm::Id> pointIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 50, 75, 100 });
// Output dataset contains input coordinate system and point data
vtkm::cont::DataSet outDataSet;
@ -41,7 +40,7 @@ public:
OutCellSetType outCellSet = extractPoints.Run(dataset.GetCellSet(), pointIds);
outDataSet.SetCellSet(outCellSet);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nPoints),
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), pointIds.GetNumberOfValues()),
"Wrong result for ExtractPoints");
}
@ -210,9 +209,8 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
// Points to extract
const int nPoints = 6;
vtkm::Id pointids[nPoints] = { 0, 4, 5, 7, 9, 10 };
vtkm::cont::ArrayHandle<vtkm::Id> pointIds = vtkm::cont::make_ArrayHandle(pointids, nPoints);
vtkm::cont::ArrayHandle<vtkm::Id> pointIds =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 4, 5, 7, 9, 10 });
// Output dataset contains input coordinate system and point data
vtkm::cont::DataSet outDataSet;
@ -223,7 +221,7 @@ public:
OutCellSetType outCellSet = extractPoints.Run(dataset.GetCellSet(), pointIds);
outDataSet.SetCellSet(outCellSet);
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), nPoints),
VTKM_TEST_ASSERT(test_equal(outCellSet.GetNumberOfCells(), pointIds.GetNumberOfValues()),
"Wrong result for ExtractPoints");
}

13
vtkm/worklet/testing/UnitTestGraphConnectivity.cxx
View File

@ -17,13 +17,12 @@ class TestGraphConnectivity
public:
void operator()() const
{
std::vector<vtkm::Id> counts{ 1, 1, 2, 2, 2 };
std::vector<vtkm::Id> offsets{ 0, 1, 2, 4, 6 };
std::vector<vtkm::Id> conn{ 2, 4, 0, 3, 2, 4, 1, 3 };
vtkm::cont::ArrayHandle<vtkm::Id> counts_h = vtkm::cont::make_ArrayHandle(counts);
vtkm::cont::ArrayHandle<vtkm::Id> offsets_h = vtkm::cont::make_ArrayHandle(offsets);
vtkm::cont::ArrayHandle<vtkm::Id> conn_h = vtkm::cont::make_ArrayHandle(conn);
vtkm::cont::ArrayHandle<vtkm::Id> counts_h =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 1, 2, 2, 2 });
vtkm::cont::ArrayHandle<vtkm::Id> offsets_h =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 4, 6 });
vtkm::cont::ArrayHandle<vtkm::Id> conn_h =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 2, 4, 0, 3, 2, 4, 1, 3 });
vtkm::cont::ArrayHandle<vtkm::Id> comps;
vtkm::worklet::connectivity::GraphConnectivity().Run(counts_h, offsets_h, conn_h, comps);

10
vtkm/worklet/testing/UnitTestImageConnectivity.cxx
View File

@ -37,7 +37,8 @@ public:
vtkm::cont::DataSetBuilderUniform builder;
vtkm::cont::DataSet data = builder.Create(vtkm::Id3(8, 4, 1));
auto colorField = vtkm::cont::make_FieldPoint("color", vtkm::cont::make_ArrayHandle(pixels));
auto colorField = vtkm::cont::make_FieldPoint(
"color", vtkm::cont::make_ArrayHandle(pixels, vtkm::CopyFlag::On));
data.AddField(colorField);
vtkm::cont::ArrayHandle<vtkm::Id> component;
@ -60,17 +61,16 @@ public:
{
// example from Figure 35.7 of Connected Component Labeling in CUDA by OndˇrejˇŚtava,
// Bedˇrich Beneˇ
std::vector<vtkm::UInt8> pixels{
auto pixels = vtkm::cont::make_ArrayHandle<vtkm::UInt8>({
0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1,
1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
};
});
vtkm::cont::DataSetBuilderUniform builder;
vtkm::cont::DataSet data = builder.Create(vtkm::Id3(8, 8, 1));
auto colorField =
vtkm::cont::make_Field("color", vtkm::cont::Field::Association::POINTS, pixels);
auto colorField = vtkm::cont::make_FieldPoint("color", pixels);
data.AddField(colorField);
vtkm::cont::ArrayHandle<vtkm::Id> component;

9
vtkm/worklet/testing/UnitTestInnerJoin.cxx
View File

@ -40,11 +40,10 @@ public:
{
using Algorithm = vtkm::cont::Algorithm;
std::vector<vtkm::Id> A = { 8, 3, 6, 8, 9, 5, 12, 10, 14 };
std::vector<vtkm::Id> B = { 7, 11, 9, 8, 5, 1, 0, 5 };
vtkm::cont::ArrayHandle<vtkm::Id> A_arr = vtkm::cont::make_ArrayHandle(A);
vtkm::cont::ArrayHandle<vtkm::Id> B_arr = vtkm::cont::make_ArrayHandle(B);
vtkm::cont::ArrayHandle<vtkm::Id> A_arr =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 8, 3, 6, 8, 9, 5, 12, 10, 14 });
vtkm::cont::ArrayHandle<vtkm::Id> B_arr =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 7, 11, 9, 8, 5, 1, 0, 5 });
vtkm::cont::ArrayHandle<vtkm::Id> idxA;
vtkm::cont::ArrayHandle<vtkm::Id> idxB;

10
vtkm/worklet/testing/UnitTestKdTreeBuildNNS.cxx
View File

@ -82,7 +82,7 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
}
///// preprare data to build 3D kd tree /////
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi);
auto coordi_Handle = vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::On);
// Run data
vtkm::worklet::KdTree3D kdtree3d;
@ -97,7 +97,7 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
}
///// preprare testing data /////
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec);
auto qc_Handle = vtkm::cont::make_ArrayHandle(qcVec, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::Id> nnId_Handle;
vtkm::cont::ArrayHandle<vtkm::Float32> nnDis_Handle;
@ -109,8 +109,10 @@ void TestKdTreeBuildNNS(vtkm::cont::DeviceAdapterId deviceId)
NearestNeighborSearchBruteForce3DWorklet nnsbf3dWorklet;
vtkm::worklet::DispatcherMapField<NearestNeighborSearchBruteForce3DWorklet> nnsbf3DDispatcher(
nnsbf3dWorklet);
nnsbf3DDispatcher.Invoke(
qc_Handle, vtkm::cont::make_ArrayHandle(coordi), bfnnId_Handle, bfnnDis_Handle);
nnsbf3DDispatcher.Invoke(qc_Handle,
vtkm::cont::make_ArrayHandle(coordi, vtkm::CopyFlag::On),
bfnnId_Handle,
bfnnDis_Handle);
///// verfity search result /////
bool passTest = true;

3
vtkm/worklet/testing/UnitTestKeys.cxx
View File

@ -57,7 +57,8 @@ void TryKeyType(KeyType)
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
}
vtkm::cont::ArrayHandle<KeyType> keyArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
vtkm::cont::ArrayHandle<KeyType> keyArray =
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<KeyType> sortedKeys;
vtkm::cont::ArrayCopy(keyArray, sortedKeys);

40
vtkm/worklet/testing/UnitTestMaskSelect.cxx
View File

@ -34,55 +34,33 @@ struct TestMaskArrays
TestMaskArrays MakeMaskArraysShort()
{
const vtkm::Id selectArraySize = 18;
const vtkm::IdComponent selectArray[selectArraySize] = { 1, 1, 0, 0, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1 };
const vtkm::Id threadRange = 4;
const vtkm::Id threadToOutputMap[threadRange] = { 0, 1, 6, 17 };
TestMaskArrays arrays;
// Need to copy arrays so that the data does not go out of scope.
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
arrays.SelectArray);
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(threadToOutputMap, threadRange),
arrays.ThreadToOutputMap);
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
{ 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 });
arrays.ThreadToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 6, 17 });
return arrays;
}
TestMaskArrays MakeMaskArraysLong()
{
const vtkm::Id selectArraySize = 16;
const vtkm::IdComponent selectArray[selectArraySize] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
};
const vtkm::Id threadRange = 15;
const vtkm::Id threadToOutputMap[threadRange] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15
};
TestMaskArrays arrays;
// Need to copy arrays so that the data does not go out of scope.
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
arrays.SelectArray);
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(threadToOutputMap, threadRange),
arrays.ThreadToOutputMap);
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
});
arrays.ThreadToOutputMap =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15 });
return arrays;
}
TestMaskArrays MakeMaskArraysZero()
{
const vtkm::Id selectArraySize = 6;
const vtkm::IdComponent selectArray[selectArraySize] = { 0, 0, 0, 0, 0, 0 };
TestMaskArrays arrays;
// Need to copy arrays so that the data does not go out of scope.
vtkm::cont::ArrayCopy(vtkm::cont::make_ArrayHandle(selectArray, selectArraySize),
arrays.SelectArray);
arrays.SelectArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 0, 0, 0 });
arrays.ThreadToOutputMap.Allocate(0);
return arrays;

7
vtkm/worklet/testing/UnitTestNDimsHistMarginalization.cxx
View File

@ -245,12 +245,11 @@ void TestNDimsHistMarginalization()
// setup for histogram marginalization
// use a bool array to indicate the marginal variable (true -> marginal variable)
// the length of this array has to be equal to number of input variables
bool marginalVariableAry[3] = { true, false, true };
vtkm::cont::ArrayHandle<bool> marginalVariable =
vtkm::cont::make_ArrayHandle(marginalVariableAry, 3);
vtkm::cont::make_ArrayHandle({ true, false, true });
std::vector<vtkm::Id> numberOfBinsVec(3, 10);
vtkm::cont::ArrayHandle<vtkm::Id> numberOfBins = vtkm::cont::make_ArrayHandle(numberOfBinsVec);
vtkm::cont::ArrayHandle<vtkm::Id> numberOfBins =
vtkm::cont::make_ArrayHandleMove(std::vector<vtkm::Id>(3, 10));
// calculate marginal histogram by the setup (return sparse represetnation)
std::vector<vtkm::cont::ArrayHandle<vtkm::Id>> marginalBinIds;

4
vtkm/worklet/testing/UnitTestNormalize.cxx
View File

@ -56,7 +56,7 @@ void TestNormal()
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> inputArray;
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> outputArray;
inputArray = vtkm::cont::make_ArrayHandle(inputVecs);
inputArray = vtkm::cont::make_ArrayHandle(inputVecs, vtkm::CopyFlag::On);
vtkm::worklet::Normal normalWorklet;
vtkm::worklet::DispatcherMapField<vtkm::worklet::Normal> dispatcherNormal(normalWorklet);
@ -91,7 +91,7 @@ void TestNormalize()
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> inputArray;
vtkm::cont::ArrayHandle<vtkm::Vec<T, N>> outputArray;
inputArray = vtkm::cont::make_ArrayHandle(inputVecs);
inputArray = vtkm::cont::make_ArrayHandle(inputVecs, vtkm::CopyFlag::On);
vtkm::worklet::Normalize normalizeWorklet;
vtkm::worklet::DispatcherMapField<vtkm::worklet::Normalize> dispatcherNormalize(normalizeWorklet);

19
vtkm/worklet/testing/UnitTestParticleAdvection.cxx
View File

@ -315,7 +315,8 @@ void ValidateEvaluator(const EvalType& eval,
using Status = vtkm::worklet::particleadvection::GridEvaluatorStatus;
EvalTester evalTester;
EvalTesterDispatcher evalTesterDispatcher(evalTester);
vtkm::cont::ArrayHandle<vtkm::Massless> pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
vtkm::cont::ArrayHandle<vtkm::Massless> pointsHandle =
vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<Status> evalStatus;
vtkm::cont::ArrayHandle<vtkm::Vec3f> evalResults;
@ -365,7 +366,7 @@ void ValidateIntegrator(const IntegratorType& integrator,
using IntegratorTesterDispatcher = vtkm::worklet::DispatcherMapField<IntegratorTester>;
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
IntegratorTesterDispatcher integratorTesterDispatcher;
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<Status> stepStatus;
vtkm::cont::ArrayHandle<vtkm::Vec3f> stepResults;
@ -398,7 +399,7 @@ void ValidateIntegratorForBoundary(const vtkm::Bounds& bounds,
using Status = vtkm::worklet::particleadvection::IntegratorStatus;
IntegratorTesterDispatcher integratorTesterDispatcher;
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns);
auto pointsHandle = vtkm::cont::make_ArrayHandle(pointIns, vtkm::CopyFlag::Off);
vtkm::Id numPoints = pointsHandle.GetNumberOfValues();
vtkm::cont::ArrayHandle<Status> stepStatus;
vtkm::cont::ArrayHandle<vtkm::Vec3f> stepResults;
@ -568,7 +569,7 @@ void TestIntegrators()
std::vector<vtkm::Vec3f> fieldData;
for (vtkm::Id i = 0; i < nElements; i++)
fieldData.push_back(vtkm::Vec3f(0., 0., 1.));
FieldHandle fieldValues = vtkm::cont::make_ArrayHandle(fieldData);
FieldHandle fieldValues = vtkm::cont::make_ArrayHandle(fieldData, vtkm::CopyFlag::Off);
FieldType velocities(fieldValues);
GridEvalType eval(dataset.GetCoordinateSystem(), dataset.GetCellSet(), velocities);
@ -616,7 +617,7 @@ void TestParticleWorkletsWithDataSetTypes()
field.push_back(vtkm::Normal(vec));
}
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldArray;
fieldArray = vtkm::cont::make_ArrayHandle(field);
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
FieldType velocities(fieldArray);
std::vector<vtkm::Bounds> bounds;
@ -713,7 +714,7 @@ void TestParticleStatus()
vtkm::FloatDefault stepSize = 0.01f;
FieldHandle fieldArray;
fieldArray = vtkm::cont::make_ArrayHandle(field);
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
FieldType velocities(fieldArray);
GridEvalType eval(ds.GetCoordinateSystem(), ds.GetCellSet(), velocities);
@ -749,8 +750,8 @@ void TestWorkletsBasic()
for (vtkm::Id i = 0; i < nElements; i++)
field.push_back(vtkm::Normal(vecDir));
FieldHandle fieldArray;
fieldArray = vtkm::cont::make_ArrayHandle(field);
vtkm::cont::ArrayHandle<vtkm::Vec3f> fieldArray;
fieldArray = vtkm::cont::make_ArrayHandle(field, vtkm::CopyFlag::Off);
FieldType velocities(fieldArray);
vtkm::Bounds bounds(0, 1, 0, 1, 0, 1);
@ -940,7 +941,7 @@ void TestParticleAdvectionFile(const std::string& fname,
std::vector<vtkm::Massless> seeds;
for (size_t j = 0; j < pts.size(); j++)
seeds.push_back(vtkm::Massless(pts[j], static_cast<vtkm::Id>(j)));
auto seedArray = vtkm::cont::make_ArrayHandle(seeds);
auto seedArray = vtkm::cont::make_ArrayHandle(seeds, vtkm::CopyFlag::Off);
if (i == 0)
{

6
vtkm/worklet/testing/UnitTestPointGradient.cxx
View File

@ -90,7 +90,8 @@ void TestPointGradientUniform3DWithVectorField()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::worklet::PointGradient gradient;
auto result = gradient.Run(dataSet.GetCellSet(), dataSet.GetCoordinateSystem(), input);
@ -134,7 +135,8 @@ void TestPointGradientUniform3DWithVectorField2()
{
vec[i] = vtkm::make_Vec(vars[i], vars[i], vars[i]);
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input = vtkm::cont::make_ArrayHandle(vec);
vtkm::cont::ArrayHandle<vtkm::Vec3f_64> input =
vtkm::cont::make_ArrayHandle(vec, vtkm::CopyFlag::On);
vtkm::worklet::GradientOutputFields<vtkm::Vec3f_64> extraOutput;
extraOutput.SetComputeGradient(false);

11
vtkm/worklet/testing/UnitTestScatterAndMaskWithTopology.cxx
View File

@ -145,16 +145,13 @@ struct DoTestWorklet<TestWorkletMapTopoSelect>
template <typename T>
VTKM_CONT void operator()(T) const
{
// 18 are the number of vertices at the DataSet created by Make3DUniformDataSet0
const vtkm::Id selectArraySize = 18;
const vtkm::IdComponent selectArray[selectArraySize] = { 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0 };
auto selectArrayHandle = vtkm::cont::make_ArrayHandle(selectArray, selectArraySize);
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet3D = testDataSet.Make3DUniformDataSet0();
// Start select array with an array of zeros
auto selectArrayHandle = vtkm::cont::make_ArrayHandleMove(
std::vector<vtkm::IdComponent>(static_cast<std::size_t>(dataSet3D.GetNumberOfPoints()), 0));
vtkm::cont::CellSetStructured<3> cellSet =
dataSet3D.GetCellSet().Cast<vtkm::cont::CellSetStructured<3>>();

58
vtkm/worklet/testing/UnitTestScatterCounting.cxx
View File

@ -33,65 +33,35 @@ struct TestScatterArrays
TestScatterArrays MakeScatterArraysShort()
{
const vtkm::Id countArraySize = 18;
const vtkm::IdComponent countArray[countArraySize] = { 1, 2, 0, 0, 1, 0, 1, 0, 0,
0, 0, 0, 0, 0, 1, 0, 0, 0 };
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 1, 3, 3, 3, 4, 4, 5, 5,
5, 5, 5, 5, 5, 5, 6, 6, 6 };
const vtkm::Id outputSize = 6;
const vtkm::Id outputToInputMap[outputSize] = { 0, 1, 1, 4, 6, 14 };
const vtkm::IdComponent visitArray[outputSize] = { 0, 0, 1, 0, 0, 0 };
TestScatterArrays arrays;
using Algorithm = vtkm::cont::Algorithm;
// Need to copy arrays so that the data does not go out of scope.
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
arrays.InputToOutputMap);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(outputToInputMap, outputSize),
arrays.OutputToInputMap);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(visitArray, outputSize), arrays.VisitArray);
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
{ 1, 2, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 });
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>(
{ 0, 1, 3, 3, 3, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6 });
arrays.OutputToInputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 1, 1, 4, 6, 14 });
arrays.VisitArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 1, 0, 0, 0 });
return arrays;
}
TestScatterArrays MakeScatterArraysLong()
{
const vtkm::Id countArraySize = 6;
const vtkm::IdComponent countArray[countArraySize] = { 0, 1, 2, 3, 4, 5 };
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 0, 1, 3, 6, 10 };
const vtkm::Id outputSize = 15;
const vtkm::Id outputToInputMap[outputSize] = { 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 };
const vtkm::IdComponent visitArray[outputSize] = { 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 };
TestScatterArrays arrays;
using Algorithm = vtkm::cont::Algorithm;
// Need to copy arrays so that the data does not go out of scope.
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
arrays.InputToOutputMap);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(outputToInputMap, outputSize),
arrays.OutputToInputMap);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(visitArray, outputSize), arrays.VisitArray);
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 1, 2, 3, 4, 5 });
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 1, 3, 6, 10 });
arrays.OutputToInputMap =
vtkm::cont::make_ArrayHandle<vtkm::Id>({ 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5 });
arrays.VisitArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>(
{ 0, 0, 1, 0, 1, 2, 0, 1, 2, 3, 0, 1, 2, 3, 4 });
return arrays;
}
TestScatterArrays MakeScatterArraysZero()
{
const vtkm::Id countArraySize = 6;
const vtkm::IdComponent countArray[countArraySize] = { 0, 0, 0, 0, 0, 0 };
const vtkm::Id inputToOutputMap[countArraySize] = { 0, 0, 0, 0, 0, 0 };
TestScatterArrays arrays;
using Algorithm = vtkm::cont::Algorithm;
// Need to copy arrays so that the data does not go out of scope.
Algorithm::Copy(vtkm::cont::make_ArrayHandle(countArray, countArraySize), arrays.CountArray);
Algorithm::Copy(vtkm::cont::make_ArrayHandle(inputToOutputMap, countArraySize),
arrays.InputToOutputMap);
arrays.CountArray = vtkm::cont::make_ArrayHandle<vtkm::IdComponent>({ 0, 0, 0, 0, 0, 0 });
arrays.InputToOutputMap = vtkm::cont::make_ArrayHandle<vtkm::Id>({ 0, 0, 0, 0, 0, 0 });
arrays.OutputToInputMap.Allocate(0);
arrays.VisitArray.Allocate(0);

2
vtkm/worklet/testing/UnitTestStreamLineUniformGrid.cxx
View File

@ -124,7 +124,7 @@ void TestStreamLineUniformGrid()
field.push_back(Normalize(vecData));
}
vtkm::cont::ArrayHandle<vtkm::Vec3f_32> fieldArray;
fieldArray = vtkm::cont::make_ArrayHandle(&field[0], nElements);
fieldArray = vtkm::cont::make_ArrayHandle(&field[0], nElements, vtkm::CopyFlag::On);
// Construct the input dataset (uniform) to hold the input and set vector data
vtkm::cont::DataSet inDataSet;

3
vtkm/worklet/testing/UnitTestWaveletCompressor.cxx
View File

@ -319,7 +319,8 @@ void TestDecomposeReconstruct1D(vtkm::Float64 cratio)
{
tmpVector.push_back(100.0 * vtkm::Sin(static_cast<vtkm::Float64>(i) / 100.0));
}
vtkm::cont::ArrayHandle<vtkm::Float64> inputArray = vtkm::cont::make_ArrayHandle(tmpVector);
vtkm::cont::ArrayHandle<vtkm::Float64> inputArray =
vtkm::cont::make_ArrayHandle(tmpVector, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<vtkm::Float64> outputArray;

57
vtkm/worklet/testing/UnitTestWholeCellSetIn.cxx
View File

@ -200,10 +200,11 @@ void TryExplicitGrid()
vtkm::Id expectedCellIndexSum[] = { 28, 22, 29, 41 };
vtkm::Id numCells = cellSet.GetNumberOfCells();
TryCellConnectivity(cellSet,
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells),
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
TryCellConnectivity(
cellSet,
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
vtkm::IdComponent expectedPointNumIndices[] = { 1, 2, 2, 1, 2, 4, 4, 2, 2, 1, 2 };
@ -213,8 +214,8 @@ void TryExplicitGrid()
TryPointConnectivity(
cellSet,
vtkm::cont::make_ArrayHandleConstant(vtkm::CellShapeTagVertex::Id, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
}
VTKM_CONT
@ -228,7 +229,8 @@ void TryCellSetPermutation()
vtkm::Id permutationArray[] = { 2, 0, 1 };
vtkm::cont::CellSetPermutation<vtkm::cont::CellSetExplicit<>, vtkm::cont::ArrayHandle<vtkm::Id>>
cellSet(vtkm::cont::make_ArrayHandle(permutationArray, 3), originalCellSet);
cellSet(vtkm::cont::make_ArrayHandle(permutationArray, 3, vtkm::CopyFlag::Off),
originalCellSet);
vtkm::UInt8 expectedCellShapes[] = { vtkm::CELL_SHAPE_TETRA,
vtkm::CELL_SHAPE_HEXAHEDRON,
@ -239,10 +241,11 @@ void TryCellSetPermutation()
vtkm::Id expectedCellIndexSum[] = { 29, 28, 22 };
vtkm::Id numCells = cellSet.GetNumberOfCells();
TryCellConnectivity(cellSet,
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells),
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
TryCellConnectivity(
cellSet,
vtkm::cont::make_ArrayHandle(expectedCellShapes, numCells, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedCellNumIndices, numCells, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
// Permutation cell set does not support cell to point connectivity.
}
@ -262,7 +265,7 @@ void TryStructuredGrid3D()
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_HEXAHEDRON, numCells),
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(8, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
vtkm::IdComponent expectedPointNumIndices[18] = { 1, 2, 1, 1, 2, 1, 2, 4, 2,
2, 4, 2, 1, 2, 1, 1, 2, 1 };
@ -273,8 +276,8 @@ void TryStructuredGrid3D()
TryPointConnectivity(
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
}
VTKM_CONT
@ -288,10 +291,11 @@ void TryStructuredGrid2D()
vtkm::Id expectedCellIndexSum[2] = { 8, 12 };
vtkm::Id numCells = cellSet.GetNumberOfCells();
TryCellConnectivity(cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_QUAD, numCells),
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(4, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
TryCellConnectivity(
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_QUAD, numCells),
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(4, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
vtkm::IdComponent expectedPointNumIndices[6] = { 1, 2, 1, 1, 2, 1 };
@ -301,8 +305,8 @@ void TryStructuredGrid2D()
TryPointConnectivity(
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
}
VTKM_CONT
@ -316,10 +320,11 @@ void TryStructuredGrid1D()
vtkm::Id expectedCellIndexSum[5] = { 1, 3, 5, 7, 9 };
vtkm::Id numCells = cellSet.GetNumberOfCells();
TryCellConnectivity(cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_LINE, numCells),
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(2, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells));
TryCellConnectivity(
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_LINE, numCells),
vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>(2, numCells),
vtkm::cont::make_ArrayHandle(expectedCellIndexSum, numCells, vtkm::CopyFlag::Off));
vtkm::IdComponent expectedPointNumIndices[6] = { 1, 2, 2, 2, 2, 1 };
@ -329,8 +334,8 @@ void TryStructuredGrid1D()
TryPointConnectivity(
cellSet,
vtkm::cont::ArrayHandleConstant<vtkm::UInt8>(vtkm::CELL_SHAPE_VERTEX, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints));
vtkm::cont::make_ArrayHandle(expectedPointNumIndices, numPoints, vtkm::CopyFlag::Off),
vtkm::cont::make_ArrayHandle(expectedPointIndexSum, numPoints, vtkm::CopyFlag::Off));
}
VTKM_CONT

6
vtkm/worklet/testing/UnitTestWorkletMapField.cxx
View File

@ -67,7 +67,8 @@ struct DoStaticTestWorklet
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
}
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<T> outputHandle, outputHandleAsPtr;
vtkm::cont::ArrayHandle<T> inoutHandle, inoutHandleAsPtr;
@ -115,7 +116,8 @@ struct DoVariantTestWorklet
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
}
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<T> outputHandle;
vtkm::cont::ArrayHandle<T> inoutHandle;

3
vtkm/worklet/testing/UnitTestWorkletMapField3d.cxx
View File

@ -142,7 +142,8 @@ struct DoTestWorklet
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
}
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<T> outputHandleAsPtr;
vtkm::cont::ArrayHandle<T> inoutHandleAsPtr;

3
vtkm/worklet/testing/UnitTestWorkletMapFieldExecArg.cxx
View File

@ -75,7 +75,8 @@ struct DoTestWorklet
}
vtkm::cont::ArrayHandleIndex counting(ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::Off);
vtkm::cont::ArrayHandle<T> outputHandle;
vtkm::cont::ArrayHandle<T> outputFieldArray;
outputHandle.Allocate(ARRAY_SIZE);

6
vtkm/worklet/testing/UnitTestWorkletMapFieldWholeArray.cxx
View File

@ -68,8 +68,10 @@ struct DoTestWholeArrayWorklet
inOutArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
}
vtkm::cont::ArrayHandle<T> inHandle = vtkm::cont::make_ArrayHandle(inArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(inOutArray, ARRAY_SIZE);
vtkm::cont::ArrayHandle<T> inHandle =
vtkm::cont::make_ArrayHandle(inArray, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<T> inOutHandle =
vtkm::cont::make_ArrayHandle(inOutArray, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<T> outHandle;
// Output arrays must be preallocated.
outHandle.Allocate(ARRAY_SIZE);

4
vtkm/worklet/testing/UnitTestWorkletMapFieldWholeArrayAtomic.cxx
View File

@ -54,9 +54,7 @@ struct DoTestAtomicArrayWorklet
VTKM_CONT void operator()(T) const
{
std::cout << "Set up data." << std::endl;
T inOutValue = 0;
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(&inOutValue, 1);
vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle<T>({ 0 });
this->CallWorklet(vtkm::cont::VariantArrayHandle(inOutHandle));

3
vtkm/worklet/testing/UnitTestWorkletReduceByKey.cxx
View File

@ -122,7 +122,8 @@ void TryKeyType(KeyType)
keyBuffer[index] = TestValue(index % NUM_UNIQUE, KeyType());
}
vtkm::cont::ArrayHandle<KeyType> keyArray = vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE);
vtkm::cont::ArrayHandle<KeyType> keyArray =
vtkm::cont::make_ArrayHandle(keyBuffer, ARRAY_SIZE, vtkm::CopyFlag::On);
vtkm::cont::ArrayHandle<KeyType> sortedKeys;
vtkm::cont::ArrayCopy(keyArray, sortedKeys);

16
vtkm/worklet/wavelets/WaveletFilter.h
View File

@ -93,6 +93,10 @@ public:
// destructor
~WaveletFilter()
{
this->LowDecomType.ReleaseResources();
this->HighDecomType.ReleaseResources();
this->LowReconType.ReleaseResources();
this->HighReconType.ReleaseResources();
if (LowDecomposeFilter)
{
delete[] LowDecomposeFilter;
@ -134,10 +138,14 @@ private:
void MakeArrayHandles()
{
LowDecomType = vtkm::cont::make_ArrayHandle(LowDecomposeFilter, FilterLength);
HighDecomType = vtkm::cont::make_ArrayHandle(HighDecomposeFilter, FilterLength);
LowReconType = vtkm::cont::make_ArrayHandle(LowReconstructFilter, FilterLength);
HighReconType = vtkm::cont::make_ArrayHandle(HighReconstructFilter, FilterLength);
LowDecomType =
vtkm::cont::make_ArrayHandle(LowDecomposeFilter, FilterLength, vtkm::CopyFlag::Off);
HighDecomType =
vtkm::cont::make_ArrayHandle(HighDecomposeFilter, FilterLength, vtkm::CopyFlag::Off);
LowReconType =
vtkm::cont::make_ArrayHandle(LowReconstructFilter, FilterLength, vtkm::CopyFlag::Off);
HighReconType =
vtkm::cont::make_ArrayHandle(HighReconstructFilter, FilterLength, vtkm::CopyFlag::Off);
}
// Flipping operation; helper function to initialize a filter.