Merge branch 'index-array-handle' into 'master'

Add ArrayHandleIndex

Add an ```ArrayHandleIndex``` class that echoes the index. This is really a special version of ```ArrayHandleCounting``` that is of type ```vtkm::Id``` and starts at 0, but it is the most common case and does not need the extra addition.

Also modified ```ArrayHandleCounting``` to support a step, which makes the use a bit more powerful.

See merge request !192

vtkm/cont/ArrayHandleCounting.h

@@ -42,20 +42,23 @@ public:
 
   VTKM_EXEC_CONT_EXPORT
   ArrayPortalCounting() :
-    StartingValue(),
+    Start(0),
+    Step(1),
     NumberOfValues(0)
   {  }
 
   VTKM_EXEC_CONT_EXPORT
-  ArrayPortalCounting(ValueType startingValue, vtkm::Id numValues) :
+  ArrayPortalCounting(ValueType start, ValueType step, vtkm::Id numValues) :
-    StartingValue(startingValue),
+    Start(start),
+    Step(step),
     NumberOfValues(numValues)
   {  }
 
   template<typename OtherValueType>
   VTKM_EXEC_CONT_EXPORT
   ArrayPortalCounting(const ArrayPortalCounting<OtherValueType> &src)
-    : StartingValue(src.StartingValue),
+    : Start(src.Start),
+      Step(src.Step),
       NumberOfValues(src.NumberOfValues)
   {  }
 
@@ -64,7 +67,8 @@ public:
   ArrayPortalCounting<ValueType> &operator=(
     const ArrayPortalCounting<OtherValueType> &src)
   {
-    this->StartingValue = src.StartingValue;
+    this->Start= src.Start;
+    this->Step = src.Step;
     this->NumberOfValues = src.NumberOfValues;
     return *this;
   }
@@ -74,12 +78,13 @@ public:
 
   VTKM_EXEC_CONT_EXPORT
   ValueType Get(vtkm::Id index) const {
-    return ValueType(StartingValue +
+    return ValueType(this->Start +
-                     ValueType(static_cast<ComponentType>(index)));
+                     this->Step*ValueType(static_cast<ComponentType>(index)));
   }
 
 private:
-  ValueType StartingValue;
+  ValueType Start;
+  ValueType Step;
   vtkm::Id NumberOfValues;
 };
 
@@ -111,8 +116,10 @@ class ArrayHandleCounting
 public:
 
   VTKM_CONT_EXPORT
-  ArrayHandleCounting(CountingValueType startingValue, vtkm::Id length)
+  ArrayHandleCounting(CountingValueType start,
-    :Superclass(typename Superclass::PortalConstControl(startingValue, length))
+                      CountingValueType step,
+                      vtkm::Id length)
+    :Superclass(typename Superclass::PortalConstControl(start, step, length))
   {
   }
 
@@ -125,10 +132,12 @@ public:
 template<typename CountingValueType>
 VTKM_CONT_EXPORT
 vtkm::cont::ArrayHandleCounting<CountingValueType>
-make_ArrayHandleCounting(CountingValueType startingValue,
+make_ArrayHandleCounting(CountingValueType start,
+                         CountingValueType step,
                          vtkm::Id length)
 {
-  return vtkm::cont::ArrayHandleCounting<CountingValueType>(startingValue,
+  return vtkm::cont::ArrayHandleCounting<CountingValueType>(start,
+                                                            step,
                                                             length);
 }
 

vtkm/cont/ArrayHandleIndex.h

@@ -0,0 +1,59 @@
+//=============================================================================
+//
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2015 Sandia Corporation.
+//  Copyright 2015 UT-Battelle, LLC.
+//  Copyright 2015 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//
+//=============================================================================
+#ifndef vtk_m_cont_ArrayHandleIndex_h
+#define vtk_m_cont_ArrayHandleIndex_h
+
+#include <vtkm/cont/ArrayHandleImplicit.h>
+
+namespace vtkm {
+namespace cont {
+
+namespace detail {
+
+struct IndexFunctor {
+  VTKM_EXEC_CONT_EXPORT
+  vtkm::Id operator()(vtkm::Id index) const { return index; }
+};
+
+} // namespace detail
+
+/// \brief An implicit array handle containing the its own indices.
+///
+/// \c ArrayHandleIndex is an implicit array handle containing the values
+/// 0, 1, 2, 3,... to a specified size. Every value in the array is the same
+/// as the index to that value.
+///
+class ArrayHandleIndex
+    : public vtkm::cont::ArrayHandleImplicit<vtkm::Id, detail::IndexFunctor>
+{
+  typedef vtkm::cont::ArrayHandleImplicit<vtkm::Id, detail::IndexFunctor>
+      Superclass;
+
+public:
+  ArrayHandleIndex(vtkm::Id length = 0)
+    : Superclass(detail::IndexFunctor(), length) {  }
+};
+
+}
+} // namespace vtkm::cont
+
+#endif //vtk_m_cont_ArrayHandleIndex_h

vtkm/cont/CMakeLists.txt

@@ -27,6 +27,7 @@ set(headers
   ArrayHandleConstant.h
   ArrayHandleCounting.h
   ArrayHandleImplicit.h
+  ArrayHandleIndex.h
   ArrayHandlePermutation.h
   ArrayHandleTransform.h
   ArrayHandleUniformPointCoordinates.h

vtkm/cont/internal/DeviceAdapterAlgorithmGeneral.h

@@ -21,8 +21,8 @@
 #define vtk_m_cont_internal_DeviceAdapterAlgorithmGeneral_h
 
 #include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/ArrayHandleImplicit.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandleZip.h>
 #include <vtkm/cont/ArrayPortalToIterators.h>
 #include <vtkm/cont/StorageBasic.h>
@@ -1204,11 +1204,7 @@ template<typename T, typename U, class CIn, class CStencil, class COut>
       const vtkm::cont::ArrayHandle<T,CStencil> &stencil,
       vtkm::cont::ArrayHandle<vtkm::Id,COut> &output)
   {
-    typedef vtkm::cont::ArrayHandleCounting<vtkm::Id> CountingHandleType;
+    vtkm::cont::ArrayHandleIndex input(stencil.GetNumberOfValues());
-
-    CountingHandleType input =
-        vtkm::cont::make_ArrayHandleCounting(vtkm::Id(0),
-                                            stencil.GetNumberOfValues());
     DerivedAlgorithm::StreamCompact(input, stencil, output);
   }
 

vtkm/cont/internal/DeviceAdapterAlgorithmSerial.h

@@ -397,7 +397,7 @@ public:
       IndexType indexArray;
       ValueType valuesScattered;
 
-      Copy( make_ArrayHandleCounting(0, keys.GetNumberOfValues()), indexArray);
+      Copy( ArrayHandleIndex(keys.GetNumberOfValues()), indexArray);
       SortByKeyDirect(keys, indexArray, wrappedCompare);
       Scatter(values, indexArray, valuesScattered);
       Copy( valuesScattered, values );

vtkm/cont/tbb/internal/DeviceAdapterAlgorithmTBB.h

@@ -27,6 +27,7 @@
 #include <vtkm/exec/internal/ErrorMessageBuffer.h>
 #include <vtkm/Extent.h>
 #include <vtkm/cont/ArrayHandle.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandleZip.h>
 #include <vtkm/cont/DeviceAdapterAlgorithm.h>
 #include <vtkm/cont/ErrorExecution.h>
@@ -652,7 +653,7 @@ public:
       ValueType valuesScattered;
       const vtkm::Id size = values.GetNumberOfValues();
 
-      Copy( make_ArrayHandleCounting(0, keys.GetNumberOfValues()), indexArray);
+      Copy( ArrayHandleIndex(keys.GetNumberOfValues()), indexArray);
 
       ZipHandleType zipHandle = vtkm::cont::make_ArrayHandleZip(keys,indexArray);
       Sort(zipHandle,KeyCompare<T,vtkm::Id,Compare>(comp));

vtkm/cont/testing/CMakeLists.txt

@@ -35,6 +35,7 @@ set(unit_tests
   UnitTestArrayHandleCounting.cxx
   UnitTestArrayHandleFancy.cxx
   UnitTestArrayHandleImplicit.cxx
+  UnitTestArrayHandleIndex.cxx
   UnitTestArrayHandlePermutation.cxx
   UnitTestArrayHandleTransform.cxx
   UnitTestArrayHandleUniformPointCoordinates.cxx

vtkm/cont/testing/TestingDeviceAdapter.h

@@ -23,8 +23,8 @@
 #include <vtkm/TypeTraits.h>
 #include <vtkm/BinaryPredicates.h>
 #include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandlePermutation.h>
 #include <vtkm/cont/ArrayHandleZip.h>
 #include <vtkm/cont/ArrayPortalToIterators.h>
@@ -765,8 +765,8 @@ private:
     std::cout << "Sort of a ArrayHandlePermutation" << std::endl;
 
     //verify that we can use ArrayHandlePermutation inplace
-    vtkm::cont::ArrayHandleCounting< vtkm::Id > index(0, ARRAY_SIZE);
+    vtkm::cont::ArrayHandleIndex index(ARRAY_SIZE);
-    vtkm::cont::ArrayHandlePermutation< vtkm::cont::ArrayHandleCounting< vtkm::Id >,
+    vtkm::cont::ArrayHandlePermutation< vtkm::cont::ArrayHandleIndex,
                                         IdArrayHandle> perm(index, sorted);
 
     //verify we can use a custom operator sort with permutation handle

vtkm/cont/testing/TestingFancyArrayHandles.h

@@ -28,6 +28,7 @@
 #include <vtkm/cont/ArrayHandleConstant.h>
 #include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/ArrayHandleImplicit.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandlePermutation.h>
 #include <vtkm/cont/ArrayHandleTransform.h>
 #include <vtkm/cont/ArrayHandleZip.h>
@@ -43,58 +44,6 @@
 namespace fancy_array_detail
 {
 
-class IncrementBy2
-{
-public:
-  VTKM_EXEC_CONT_EXPORT
-  IncrementBy2(): Value(0)
-  {
-
-  }
-
-  VTKM_EXEC_CONT_EXPORT
-  explicit IncrementBy2(vtkm::Id value): Value(2*value) {  }
-
-  VTKM_EXEC_CONT_EXPORT
-  operator vtkm::Id() const { return this->Value; }
-
-  VTKM_EXEC_CONT_EXPORT
-  IncrementBy2 operator+(const IncrementBy2 &rhs) const
-  {
-    //don't want to trigger the vtkm::Id constructor
-    //when making a copy and cause this to be IncrementBy4
-    IncrementBy2 newValue;
-    newValue.Value = this->Value + rhs.Value;
-    return newValue;
-  }
-
-  VTKM_EXEC_CONT_EXPORT
-  bool operator==(const IncrementBy2 &other) const
-  {
-    return this->Value == other.Value;
-  }
-
-  VTKM_EXEC_CONT_EXPORT
-  IncrementBy2 &operator++()
-  {
-    this->Value++;
-    this->Value++;
-    return *this;
-  }
-
-  VTKM_CONT_EXPORT
-  friend std::ostream& operator<<(std::ostream &os, const IncrementBy2 &v)
-  { os << v.Value; return os; }
-
-
-  vtkm::Id Value;
-};
-
-IncrementBy2 TestValue(vtkm::Id index, IncrementBy2)
-{
-  return IncrementBy2(::TestValue(index, vtkm::Id()));
-}
-
 template<typename ValueType>
 struct IndexSquared
 {
@@ -113,28 +62,10 @@ struct ValueSquared
   VTKM_EXEC_CONT_EXPORT
   ValueType operator()(U u) const
     { return vtkm::dot(u, u); }
-
-  VTKM_EXEC_CONT_EXPORT
-  ValueType operator()( ::fancy_array_detail::IncrementBy2 u) const
-    { return ValueType( vtkm::dot(u.Value, u.Value) ); }
 };
 
 }
 
-VTKM_BASIC_TYPE_VECTOR(::fancy_array_detail::IncrementBy2)
-
-namespace vtkm { namespace testing {
-template<>
-struct TypeName< ::fancy_array_detail::IncrementBy2 >
-{
-  static std::string Name()
-  {
-    return std::string("fancy_array_detail::IncrementBy2");
-  }
-};
-
-} }
-
 namespace vtkm {
 namespace cont {
 namespace testing {
@@ -247,7 +178,7 @@ private:
       const ValueType start = ValueType(component_value);
 
       vtkm::cont::ArrayHandleCounting< ValueType > counting =
-          vtkm::cont::make_ArrayHandleCounting(start, length);
+          vtkm::cont::make_ArrayHandleCounting(start, ValueType(1), length);
       vtkm::cont::ArrayHandle< ValueType > result;
 
       vtkm::worklet::DispatcherMapField< PassThrough, DeviceAdapterTag > dispatcher;
@@ -322,6 +253,7 @@ private:
 
         KeyHandleType counting =
             vtkm::cont::make_ArrayHandleCounting<vtkm::Id>(start_pos,
+                                                           1,
                                                            counting_length);
 
         ValueHandleType implicit =
@@ -419,9 +351,9 @@ private:
       ComponentType component_value(0);
       const ValueType start = ValueType(component_value);
 
-      vtkm::cont::ArrayHandleCounting< ValueType > counting =
+      vtkm::cont::ArrayHandleCounting< ValueType > counting(start,
-                                vtkm::cont::make_ArrayHandleCounting(start,
+                                                            ValueType(1),
-                                                                     length);
+                                                            length);
 
       vtkm::cont::ArrayHandleTransform<
           OutputValueType,
@@ -459,9 +391,9 @@ private:
     VTKM_CONT_EXPORT
     void operator()(CastToType vtkmNotUsed(type)) const
     {
-      typedef vtkm::cont::ArrayHandleCounting<vtkm::Int64> InputArrayType;
+      typedef vtkm::cont::ArrayHandleIndex InputArrayType;
 
-      InputArrayType input(0, ARRAY_SIZE);
+      InputArrayType input(ARRAY_SIZE);
       vtkm::cont::ArrayHandleCast<CastToType, InputArrayType> castArray =
           vtkm::cont::make_ArrayHandleCast(input, CastToType());
       vtkm::cont::ArrayHandle<CastToType> result;
@@ -556,7 +488,7 @@ private:
       values.Allocate(length*2);
 
       KeyHandleType counting =
-        vtkm::cont::make_ArrayHandleCounting<vtkm::Id>(length, length);
+        vtkm::cont::make_ArrayHandleCounting<vtkm::Id>(length, 1, length);
 
       PermutationHandleType permutation =
         vtkm::cont::make_ArrayHandlePermutation(counting, values);
@@ -641,8 +573,7 @@ private:
                          vtkm::Float32,
                          vtkm::Float64,
                          vtkm::Vec<vtkm::Float64,3>,
-                         vtkm::Vec<vtkm::Float32,4>,
+                         vtkm::Vec<vtkm::Float32,4>
-                         ::fancy_array_detail::IncrementBy2
                          >
   {  };
 

vtkm/cont/testing/UnitTestArrayHandleCounting.cxx

@@ -54,6 +54,16 @@ public:
     return StringInt(this->Value + rhs.Value);
   }
 
+  StringInt operator*(const StringInt &rhs) const
+  {
+    StringInt result;
+    for (vtkm::Id i = 0; i < rhs; i++)
+    {
+      result = result + *this;
+    }
+    return result;
+  }
+
   bool operator==(const StringInt &other) const
   {
     return this->Value.size() == other.Value.size();
@@ -88,14 +98,14 @@ struct TemplatedTests
 
   typedef typename ArrayHandleType::PortalConstControl PortalType;
 
-  void operator()( const ValueType startingValue )
+  void operator()(const ValueType &startingValue, const ValueType &step)
   {
-    ArrayHandleType arrayConst(startingValue, ARRAY_SIZE);
+    ArrayHandleType arrayConst(startingValue, step, ARRAY_SIZE);
 
-    ArrayHandleType arrayMake = vtkm::cont::make_ArrayHandleCounting(startingValue,ARRAY_SIZE);
+    ArrayHandleType arrayMake = vtkm::cont::make_ArrayHandleCounting(startingValue, step, ARRAY_SIZE);
 
     ArrayHandleType2 arrayHandle =
-      ArrayHandleType2(PortalType(startingValue, ARRAY_SIZE));
+      ArrayHandleType2(PortalType(startingValue, step, ARRAY_SIZE));
 
     VTKM_TEST_ASSERT(arrayConst.GetNumberOfValues() == ARRAY_SIZE,
                      "Counting array using constructor has wrong size.");
@@ -116,28 +126,21 @@ struct TemplatedTests
 
       VTKM_TEST_ASSERT(arrayHandle.GetPortalConstControl().Get(index) == properValue,
                        "Counting array using raw array handle + tag has unexpected value.");
-      ++properValue;
+      properValue = properValue + step;
     }
   }
 };
 
-struct TestFunctor
-{
-  template <typename T>
-  void operator()(const T t)
-  {
-    TemplatedTests<T> tests;
-    tests(t);
-  }
-};
-
 void TestArrayHandleCounting()
 {
-  TestFunctor()(vtkm::Id(0));
+  TemplatedTests<vtkm::Id>()(0, 1);
-  TestFunctor()(vtkm::Float32(0));
+  TemplatedTests<vtkm::Id>()(8, 2);
-  TestFunctor()(vtkm::Float64(0));
+  TemplatedTests<vtkm::Float32>()(0.0f, 1.0f);
-  TestFunctor()(StringInt(0));
+  TemplatedTests<vtkm::Float32>()(3.0f, -0.5f);
-  TestFunctor()(StringInt(10));
+  TemplatedTests<vtkm::Float64>()(0.0, 1.0);
+  TemplatedTests<vtkm::Float64>()(-3.0, 2.0);
+  TemplatedTests<StringInt>()(StringInt(0), StringInt(1));
+  TemplatedTests<StringInt>()(StringInt(10), StringInt(2));
 }
 
 

vtkm/cont/testing/UnitTestArrayHandleIndex.cxx

@@ -0,0 +1,47 @@
+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2015 Sandia Corporation.
+//  Copyright 2015 UT-Battelle, LLC.
+//  Copyright 2015 Los Alamos National Security.
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/cont/ArrayHandleIndex.h>
+
+#include <vtkm/cont/testing/Testing.h>
+
+namespace UnitTestArrayHandleIndexNamespace {
+
+const vtkm::Id ARRAY_SIZE = 10;
+
+void TestArrayHandleIndex()
+{
+  vtkm::cont::ArrayHandleIndex array(ARRAY_SIZE);
+  VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE, "Bad size.");
+
+  for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
+  {
+    VTKM_TEST_ASSERT(array.GetPortalConstControl().Get(index) == index,
+                     "Index array has unexpected value.");
+  }
+}
+
+} // namespace UnitTestArrayHandleIndexNamespace
+
+int UnitTestArrayHandleIndex(int, char *[])
+{
+  using namespace UnitTestArrayHandleIndexNamespace;
+  return vtkm::cont::testing::Testing::Run(TestArrayHandleIndex);
+}

vtkm/cont/testing/UnitTestArrayHandleTransform.cxx

@@ -142,6 +142,7 @@ struct TransformTests
               << std::endl;
     vtkm::cont::ArrayHandleCounting<InputValueType> counting =
         vtkm::cont::make_ArrayHandleCounting(InputValueType(OutputValueType(0)),
+                                             InputValueType(1),
                                              ARRAY_SIZE);
     CountingTransformHandle countingTransformed =
       vtkm::cont::make_ArrayHandleTransform<OutputValueType>(counting, functor);

vtkm/worklet/AverageByKey.h

@@ -26,7 +26,7 @@
 #include <vtkm/cont/DeviceAdapterAlgorithm.h>
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandlePermutation.h>
 #include <vtkm/cont/ArrayHandleZip.h>
 
@@ -71,7 +71,7 @@ void AverageByKey(const vtkm::cont::ArrayHandle<KeyType, KeyInStorage> &keyArray
   typedef vtkm::cont::ArrayHandle<ValueType> ValueArray;
 
   // sort the indexed array
-  vtkm::cont::ArrayHandleCounting<vtkm::Id> indexArray(0, keyArray.GetNumberOfValues());
+  vtkm::cont::ArrayHandleIndex indexArray(keyArray.GetNumberOfValues());
   IdArray indexArraySorted;
   vtkm::cont::ArrayHandle<KeyType> keyArraySorted;
 

vtkm/worklet/ExternalFaces.h

@@ -25,8 +25,8 @@
 
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/ArrayHandleConstant.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/ArrayHandleImplicit.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/ArrayHandlePermutation.h>
 #include <vtkm/cont/CellSetExplicit.h>
 #include <vtkm/cont/DataSet.h>
@@ -280,7 +280,8 @@ public:
     vtkm::cont::ArrayHandle<vtkm::Id> face2CellId;
     vtkm::cont::ArrayHandle<vtkm::Id> localFaceIds;
     localFaceIds.Allocate(static_cast<vtkm::Id>(totalFaces));
-    vtkm::cont::ArrayHandleCounting<vtkm::Id> countingArray(vtkm::Id(0), vtkm::Id(totalFaces));
+    vtkm::cont::ArrayHandleIndex countingArray =
+        vtkm::cont::ArrayHandleIndex(vtkm::Id(totalFaces));
 
 #ifdef __VTKM_EXTERNAL_FACES_BENCHMARK
     timer.Reset();

vtkm/worklet/IsosurfaceUniformGrid.h

@@ -23,7 +23,7 @@
 
 #include <vtkm/cont/DeviceAdapter.h>
 #include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/DynamicArrayHandle.h>
 #include <vtkm/worklet/DispatcherMapField.h>
 #include <vtkm/worklet/WorkletMapField.h>
@@ -309,7 +309,7 @@ public:
     if (numOutputCells == 0) return;
 
     vtkm::cont::ArrayHandle<vtkm::Id> validCellIndicesArray, inputCellIterationNumber;
-    vtkm::cont::ArrayHandleCounting<vtkm::Id> validCellCountImplicitArray(0, numOutputCells);
+    vtkm::cont::ArrayHandleIndex validCellCountImplicitArray(numOutputCells);
     DeviceAlgorithms::UpperBounds(numOutputTrisPerCell,
                                   validCellCountImplicitArray,
                                   validCellIndicesArray);

vtkm/worklet/testing/UnitTestIsosurfaceUniformGrid.cxx

@@ -75,7 +75,7 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
   float maxs[3] = {1.0f, 1.0f, 1.0f};
 
   vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
-  vtkm::cont::ArrayHandleCounting<vtkm::Id> vertexCountImplicitArray(0, vdims[0]*vdims[1]*vdims[2]);
+  vtkm::cont::ArrayHandleIndex vertexCountImplicitArray(vdims[0]*vdims[1]*vdims[2]);
   vtkm::worklet::DispatcherMapField<TangleField> tangleFieldDispatcher(TangleField(vdims, mins, maxs));
   tangleFieldDispatcher.Invoke(vertexCountImplicitArray, fieldArray);
 

vtkm/worklet/testing/UnitTestVertexClustering.cxx

@@ -20,7 +20,6 @@
 
 #include <iostream>
 
-#include <vtkm/cont/ArrayHandleCounting.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/DeviceAdapter.h>
 #include <vtkm/cont/testing/MakeTestDataSet.h>

vtkm/worklet/testing/UnitTestWorkletMapFieldExecArg.cxx

@@ -18,7 +18,7 @@
 //  this software.
 //============================================================================
 #include <vtkm/cont/ArrayHandle.h>
-#include <vtkm/cont/ArrayHandleCounting.h>
+#include <vtkm/cont/ArrayHandleIndex.h>
 #include <vtkm/cont/DynamicArrayHandle.h>
 
 #include <vtkm/worklet/DispatcherMapField.h>
@@ -76,7 +76,7 @@ struct DoTestWorklet
       inputArray[index] = TestValue(index, T()) + T(100);
     }
 
-    vtkm::cont::ArrayHandleCounting<vtkm::Id> counting(0,ARRAY_SIZE);
+    vtkm::cont::ArrayHandleIndex counting(ARRAY_SIZE);
     vtkm::cont::ArrayHandle<T> inputHandle =
         vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
     vtkm::cont::ArrayHandle<T> outputHandle;