diff --git a/benchmarking/BenchmarkFieldAlgorithms.cxx b/benchmarking/BenchmarkFieldAlgorithms.cxx
index a23c2c3b8..8a690f073 100644
--- a/benchmarking/BenchmarkFieldAlgorithms.cxx
+++ b/benchmarking/BenchmarkFieldAlgorithms.cxx
@@ -226,20 +226,20 @@ public:
   using ExecutionSignature = void(_1, _2, _3, _4);
   using InputDomain = _1;
 
-  template <typename WeightType, typename T, typename S, typename D>
+  template <typename WeightType, typename T, typename S>
   VTKM_EXEC void operator()(const vtkm::Id2& low_high,
                             const WeightType& weight,
-                            const vtkm::exec::ExecutionWholeArrayConst<T, S, D>& inPortal,
+                            const vtkm::exec::ExecutionWholeArrayConst<T, S>& inPortal,
                             T& result) const
   {
     //fetch the low / high values from inPortal
     result = vtkm::Lerp(inPortal.Get(low_high[0]), inPortal.Get(low_high[1]), weight);
   }
 
-  template <typename WeightType, typename T, typename S, typename D, typename U>
+  template <typename WeightType, typename T, typename S, typename U>
   VTKM_EXEC void operator()(const vtkm::Id2&,
                             const WeightType&,
-                            const vtkm::exec::ExecutionWholeArrayConst<T, S, D>&,
+                            const vtkm::exec::ExecutionWholeArrayConst<T, S>&,
                             U&) const
   {
     //the inPortal and result need to be the same type so this version only
diff --git a/vtkm/cont/arg/TransportTagWholeArrayIn.h b/vtkm/cont/arg/TransportTagWholeArrayIn.h
index c4dad8e93..86454234d 100644
--- a/vtkm/cont/arg/TransportTagWholeArrayIn.h
+++ b/vtkm/cont/arg/TransportTagWholeArrayIn.h
@@ -56,7 +56,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayIn, ContObjectType, Devi
   using ValueType = typename ContObjectType::ValueType;
   using StorageTag = typename ContObjectType::StorageTag;
 
-  using ExecObjectType = vtkm::exec::ExecutionWholeArrayConst<ValueType, StorageTag, Device>;
+  using ExecObjectType = vtkm::exec::ExecutionWholeArrayConst<ValueType, StorageTag>;
 
   template <typename InputDomainType>
   VTKM_CONT ExecObjectType operator()(ContObjectType& array,
@@ -69,7 +69,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayIn, ContObjectType, Devi
     // array might not have the same size depending on how the user is using
     // the array.
 
-    return ExecObjectType(array, token);
+    return ExecObjectType(array, Device{}, token);
   }
 
 #ifdef VTKM_MSVC
diff --git a/vtkm/cont/arg/TransportTagWholeArrayInOut.h b/vtkm/cont/arg/TransportTagWholeArrayInOut.h
index 0d5375ba0..a96c2acdd 100644
--- a/vtkm/cont/arg/TransportTagWholeArrayInOut.h
+++ b/vtkm/cont/arg/TransportTagWholeArrayInOut.h
@@ -58,7 +58,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayInOut, ContObjectType, D
   using ValueType = typename ContObjectType::ValueType;
   using StorageTag = typename ContObjectType::StorageTag;
 
-  using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag, Device>;
+  using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag>;
 
   template <typename InputDomainType>
   VTKM_CONT ExecObjectType operator()(ContObjectType& array,
@@ -71,7 +71,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayInOut, ContObjectType, D
     // array might not have the same size depending on how the user is using
     // the array.
 
-    return ExecObjectType(array, token);
+    return ExecObjectType(array, Device{}, token);
   }
 
 #ifdef VTKM_MSVC
diff --git a/vtkm/cont/arg/TransportTagWholeArrayOut.h b/vtkm/cont/arg/TransportTagWholeArrayOut.h
index 02eb6c975..6bb0542ed 100644
--- a/vtkm/cont/arg/TransportTagWholeArrayOut.h
+++ b/vtkm/cont/arg/TransportTagWholeArrayOut.h
@@ -58,7 +58,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayOut, ContObjectType, Dev
   using ValueType = typename ContObjectType::ValueType;
   using StorageTag = typename ContObjectType::StorageTag;
 
-  using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag, Device>;
+  using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag>;
 
   template <typename InputDomainType>
   VTKM_CONT ExecObjectType operator()(ContObjectType& array,
@@ -71,7 +71,7 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayOut, ContObjectType, Dev
     // array might not have the same size depending on how the user is using
     // the array.
 
-    return ExecObjectType(array, array.GetNumberOfValues(), token);
+    return ExecObjectType(array, array.GetNumberOfValues(), Device{}, token);
   }
 
 #ifdef VTKM_MSVC
diff --git a/vtkm/cont/internal/ArrayHandleDeprecated.h b/vtkm/cont/internal/ArrayHandleDeprecated.h
index 13debc4f3..b04c77b64 100644
--- a/vtkm/cont/internal/ArrayHandleDeprecated.h
+++ b/vtkm/cont/internal/ArrayHandleDeprecated.h
@@ -43,6 +43,10 @@ private:
 
   mutable vtkm::cont::internal::Buffer BufferAsStorageWrapper;
 
+  struct PrepareForInputFunctor;
+  struct PrepareForOutputFunctor;
+  struct PrepareForInPlaceFunctor;
+
 public:
   using StorageType = vtkm::cont::internal::Storage<T, StorageTag_>;
   using ValueType = T;
@@ -359,9 +363,9 @@ public:
   /// already attached. This can potentially lead to deadlocks.
   ///
   template <typename DeviceAdapterTag>
-  VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::PortalConst PrepareForInput(
-    DeviceAdapterTag,
-    vtkm::cont::Token& token) const;
+  VTKM_CONT ReadPortalType PrepareForInput(DeviceAdapterTag, vtkm::cont::Token& token) const;
+  VTKM_CONT ReadPortalType PrepareForInput(vtkm::cont::DeviceAdapterId device,
+                                           vtkm::cont::Token& token) const;
 
   /// Prepares (allocates) this array to be used as an output from an operation
   /// in the execution environment. The internal state of this class is set to
@@ -378,8 +382,12 @@ public:
   /// already attached. This can potentially lead to deadlocks.
   ///
   template <typename DeviceAdapterTag>
-  VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal
-  PrepareForOutput(vtkm::Id numberOfValues, DeviceAdapterTag, vtkm::cont::Token& token);
+  VTKM_CONT WritePortalType PrepareForOutput(vtkm::Id numberOfValues,
+                                             DeviceAdapterTag,
+                                             vtkm::cont::Token& token);
+  VTKM_CONT WritePortalType PrepareForOutput(vtkm::Id numberOfValues,
+                                             vtkm::cont::DeviceAdapterId device,
+                                             vtkm::cont::Token& token);
 
   /// Prepares this array to be used in an in-place operation (both as input
   /// and output) in the execution environment. If necessary, copies data to
@@ -395,9 +403,9 @@ public:
   /// already attached. This can potentially lead to deadlocks.
   ///
   template <typename DeviceAdapterTag>
-  VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal PrepareForInPlace(
-    DeviceAdapterTag,
-    vtkm::cont::Token& token);
+  VTKM_CONT WritePortalType PrepareForInPlace(DeviceAdapterTag, vtkm::cont::Token& token);
+  VTKM_CONT WritePortalType PrepareForInPlace(vtkm::cont::DeviceAdapterId device,
+                                              vtkm::cont::Token& token);
 
   template <typename DeviceAdapterTag>
   VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForInput now requires a vtkm::cont::Token object.")
@@ -959,9 +967,9 @@ void ArrayHandleDeprecated<T, S>::Shrink(vtkm::Id numberOfValues, vtkm::cont::To
 
 template <typename T, typename S>
 template <typename DeviceAdapterTag>
-typename ArrayHandleDeprecated<T, S>::template ExecutionTypes<DeviceAdapterTag>::PortalConst
-ArrayHandleDeprecated<T, S>::PrepareForInput(DeviceAdapterTag device,
-                                             vtkm::cont::Token& token) const
+typename ArrayHandleDeprecated<T, S>::ReadPortalType ArrayHandleDeprecated<T, S>::PrepareForInput(
+  DeviceAdapterTag device,
+  vtkm::cont::Token& token) const
 {
   VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
 
@@ -985,12 +993,36 @@ ArrayHandleDeprecated<T, S>::PrepareForInput(DeviceAdapterTag device,
   return portal;
 }
 
+template <typename T, typename S>
+struct ArrayHandleDeprecated<T, S>::PrepareForInputFunctor
+{
+  template <typename Device>
+  bool operator()(Device device,
+                  const ArrayHandleDeprecated<T, S>& self,
+                  vtkm::cont::Token& token,
+                  ReadPortalType& portal) const
+  {
+    portal = self.PrepareForInput(device, token);
+    return true;
+  }
+};
+
+template <typename T, typename S>
+typename ArrayHandleDeprecated<T, S>::ReadPortalType ArrayHandleDeprecated<T, S>::PrepareForInput(
+  vtkm::cont::DeviceAdapterId device,
+  vtkm::cont::Token& token) const
+{
+  ReadPortalType portal;
+  vtkm::cont::TryExecuteOnDevice(device, PrepareForInputFunctor{}, *this, token, portal);
+  return portal;
+}
+
 template <typename T, typename S>
 template <typename DeviceAdapterTag>
-typename ArrayHandleDeprecated<T, S>::template ExecutionTypes<DeviceAdapterTag>::Portal
-ArrayHandleDeprecated<T, S>::PrepareForOutput(vtkm::Id numberOfValues,
-                                              DeviceAdapterTag device,
-                                              vtkm::cont::Token& token)
+typename ArrayHandleDeprecated<T, S>::WritePortalType ArrayHandleDeprecated<T, S>::PrepareForOutput(
+  vtkm::Id numberOfValues,
+  DeviceAdapterTag device,
+  vtkm::cont::Token& token)
 {
   VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
 
@@ -1020,9 +1052,36 @@ ArrayHandleDeprecated<T, S>::PrepareForOutput(vtkm::Id numberOfValues,
   return portal;
 }
 
+template <typename T, typename S>
+struct ArrayHandleDeprecated<T, S>::PrepareForOutputFunctor
+{
+  template <typename Device>
+  bool operator()(Device device,
+                  ArrayHandleDeprecated<T, S>& self,
+                  vtkm::Id numberOfValues,
+                  vtkm::cont::Token& token,
+                  WritePortalType& portal) const
+  {
+    portal = self.PrepareForOutput(numberOfValues, device, token);
+    return true;
+  }
+};
+
+template <typename T, typename S>
+typename ArrayHandleDeprecated<T, S>::WritePortalType ArrayHandleDeprecated<T, S>::PrepareForOutput(
+  vtkm::Id numberOfValues,
+  vtkm::cont::DeviceAdapterId device,
+  vtkm::cont::Token& token)
+{
+  WritePortalType portal;
+  vtkm::cont::TryExecuteOnDevice(
+    device, PrepareForOutputFunctor{}, *this, numberOfValues, token, portal);
+  return portal;
+}
+
 template <typename T, typename S>
 template <typename DeviceAdapterTag>
-typename ArrayHandleDeprecated<T, S>::template ExecutionTypes<DeviceAdapterTag>::Portal
+typename ArrayHandleDeprecated<T, S>::WritePortalType
 ArrayHandleDeprecated<T, S>::PrepareForInPlace(DeviceAdapterTag device, vtkm::cont::Token& token)
 {
   VTKM_IS_DEVICE_ADAPTER_TAG(DeviceAdapterTag);
@@ -1052,6 +1111,30 @@ ArrayHandleDeprecated<T, S>::PrepareForInPlace(DeviceAdapterTag device, vtkm::co
   return portal;
 }
 
+template <typename T, typename S>
+struct ArrayHandleDeprecated<T, S>::PrepareForInPlaceFunctor
+{
+  template <typename Device>
+  bool operator()(Device device,
+                  ArrayHandleDeprecated<T, S>& self,
+                  vtkm::cont::Token& token,
+                  ReadPortalType& portal) const
+  {
+    portal = self.PrepareForInPlace(device, token);
+    return true;
+  }
+};
+
+template <typename T, typename S>
+typename ArrayHandleDeprecated<T, S>::WritePortalType
+ArrayHandleDeprecated<T, S>::PrepareForInPlace(vtkm::cont::DeviceAdapterId device,
+                                               vtkm::cont::Token& token)
+{
+  WritePortalType portal;
+  vtkm::cont::TryExecuteOnDevice(device, PrepareForInPlaceFunctor{}, *this, token, portal);
+  return portal;
+}
+
 template <typename T, typename S>
 template <typename DeviceAdapterTag>
 void ArrayHandleDeprecated<T, S>::PrepareForDevice(LockType& lock,
diff --git a/vtkm/exec/ExecutionWholeArray.h b/vtkm/exec/ExecutionWholeArray.h
index ce74966df..bd71c6dcf 100644
--- a/vtkm/exec/ExecutionWholeArray.h
+++ b/vtkm/exec/ExecutionWholeArray.h
@@ -13,12 +13,14 @@
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkm/cont/DeviceAdapter.h>
 
+#include <vtkm/Deprecated.h>
+
 namespace vtkm
 {
 namespace exec
 {
 
-/// The following classes have been deprecated and are meant to be used
+/// The following classes have been sort of deprecated and are meant to be used
 /// internally only. Please use the \c WholeArrayIn, \c WholeArrayOut, and
 /// \c WholeArrayInOut \c ControlSignature tags instead.
 
@@ -27,8 +29,11 @@ namespace exec
 /// function. This can be used to allow worklets to have a shared search
 /// structure.
 ///
-template <typename T, typename StorageTag, typename DeviceAdapterTag>
-class ExecutionWholeArray
+template <typename T, typename StorageTag, typename... MaybeDevice>
+class ExecutionWholeArray;
+
+template <typename T, typename StorageTag>
+class ExecutionWholeArray<T, StorageTag>
 {
 public:
   using ValueType = T;
@@ -41,29 +46,20 @@ public:
   {
   }
 
-  // This constructor is deprecated in VTK-m 1.6
   VTKM_CONT
-  ExecutionWholeArray(HandleType& handle)
-    : Portal(handle.PrepareForInPlace(DeviceAdapterTag()))
-  {
-  }
-
-  // This constructor is deprecated in VTK-m 1.6
-  VTKM_CONT
-  ExecutionWholeArray(HandleType& handle, vtkm::Id length)
-    : Portal(handle.PrepareForOutput(length, DeviceAdapterTag()))
+  ExecutionWholeArray(HandleType& handle,
+                      vtkm::cont::DeviceAdapterId device,
+                      vtkm::cont::Token& token)
+    : Portal(handle.PrepareForInPlace(device, token))
   {
   }
 
   VTKM_CONT
-  ExecutionWholeArray(HandleType& handle, vtkm::cont::Token& token)
-    : Portal(handle.PrepareForInPlace(DeviceAdapterTag(), token))
-  {
-  }
-
-  VTKM_CONT
-  ExecutionWholeArray(HandleType& handle, vtkm::Id length, vtkm::cont::Token& token)
-    : Portal(handle.PrepareForOutput(length, DeviceAdapterTag(), token))
+  ExecutionWholeArray(HandleType& handle,
+                      vtkm::Id length,
+                      vtkm::cont::DeviceAdapterId device,
+                      vtkm::cont::Token& token)
+    : Portal(handle.PrepareForOutput(length, device, token))
   {
   }
 
@@ -86,13 +82,50 @@ private:
   PortalType Portal;
 };
 
+template <typename T, typename StorageTag, typename Device>
+class VTKM_DEPRECATED(1.6, "ExecutionWholeArray no longer uses Device template parameter.")
+  ExecutionWholeArray<T, StorageTag, Device> : public ExecutionWholeArray<T, StorageTag>
+{
+  using Superclass = ExecutionWholeArray<T, StorageTag>;
+  using HandleType = typename Superclass::HandleType;
+
+public:
+  using Superclass::Superclass;
+
+  VTKM_CONT ExecutionWholeArray(HandleType& handle)
+    : Superclass(handle, Device{}, vtkm::cont::Token{})
+  {
+  }
+
+  VTKM_CONT
+  ExecutionWholeArray(HandleType& handle, vtkm::Id length)
+    : Superclass(handle, length, Device{}, vtkm::cont::Token{})
+  {
+  }
+
+  VTKM_CONT
+  ExecutionWholeArray(HandleType& handle, vtkm::cont::Token& token)
+    : Superclass(handle, Device{}, token)
+  {
+  }
+
+  VTKM_CONT
+  ExecutionWholeArray(HandleType& handle, vtkm::Id length, vtkm::cont::Token& token)
+    : Superclass(handle, length, Device{}, token)
+  {
+  }
+};
+
 /// \c ExecutionWholeArrayConst is an execution object that allows an array handle
 /// content to be a parameter in an execution environment
 /// function. This can be used to allow worklets to have a shared search
 /// structure
 ///
-template <typename T, typename StorageTag, typename DeviceAdapterTag>
-class ExecutionWholeArrayConst
+template <typename T, typename StorageTag, typename... MaybeDevice>
+class ExecutionWholeArrayConst;
+
+template <typename T, typename StorageTag>
+class ExecutionWholeArrayConst<T, StorageTag>
 {
 public:
   using ValueType = T;
@@ -105,16 +138,11 @@ public:
   {
   }
 
-  // This constructor is deprecated in VTK-m 1.6
   VTKM_CONT
-  ExecutionWholeArrayConst(const HandleType& handle)
-    : Portal(handle.PrepareForInput(DeviceAdapterTag()))
-  {
-  }
-
-  VTKM_CONT
-  ExecutionWholeArrayConst(const HandleType& handle, vtkm::cont::Token& token)
-    : Portal(handle.PrepareForInput(DeviceAdapterTag(), token))
+  ExecutionWholeArrayConst(const HandleType& handle,
+                           vtkm::cont::DeviceAdapterId device,
+                           vtkm::cont::Token& token)
+    : Portal(handle.PrepareForInput(device, token))
   {
   }
 
@@ -133,6 +161,30 @@ public:
 private:
   PortalType Portal;
 };
+
+template <typename T, typename StorageTag, typename Device>
+class VTKM_DEPRECATED(1.6, "ExecutionWholeArray no longer uses Device template parameter.")
+  ExecutionWholeArrayConst<T, StorageTag, Device> : public ExecutionWholeArrayConst<T, StorageTag>
+{
+  using Superclass = ExecutionWholeArrayConst<T, StorageTag>;
+  using HandleType = typename Superclass::HandleType;
+
+public:
+  using Superclass::Superclass;
+
+  VTKM_CONT ExecutionWholeArrayConst(HandleType& handle)
+    : Superclass(handle, Device{}, vtkm::cont::Token{})
+  {
+  }
+
+  VTKM_CONT
+  ExecutionWholeArrayConst(HandleType& handle, vtkm::cont::Token& token)
+    : Superclass(handle, Device{}, token)
+  {
+  }
+};
+
+
 }
 } // namespace vtkm::exec