Rename device_vector -> remote_vector and device_span -> (#1612)

Author: BenBrock

include/oneapi/dpl/internal/distributed_ranges_impl/shp/containers/duplicated_vector.hpp

@@ -5,7 +5,7 @@
 #pragma once
 
 #include <oneapi/dpl/internal/distributed_ranges_impl/shp/allocators.hpp>
-#include <oneapi/dpl/internal/distributed_ranges_impl/shp/device_vector.hpp>
+#include <oneapi/dpl/internal/distributed_ranges_impl/shp/remote_vector.hpp>
 
 namespace oneapi::dpl::experimental::dr::shp
 {
@@ -14,7 +14,7 @@ template <typename T, typename Allocator = device_allocator<T>>
 class duplicated_vector
 {
   public:
-    using segment_type = device_vector<T, Allocator>;
+    using segment_type = remote_vector<T, Allocator>;
 
     using value_type = T;
     using size_type = std::size_t;

include/oneapi/dpl/internal/distributed_ranges_impl/shp/distributed_span.hpp

@@ -10,7 +10,7 @@
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/iterator_adaptor.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/ranges.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/segments_tools.hpp>
-#include <oneapi/dpl/internal/distributed_ranges_impl/shp/device_span.hpp>
+#include <oneapi/dpl/internal/distributed_ranges_impl/shp/remote_span.hpp>
 
 namespace oneapi::dpl::experimental::dr::shp
 {
@@ -151,7 +151,7 @@ class distributed_span : public rng::view_interface<distributed_span<T, L>>
     using element_type = T;
     using value_type = std::remove_cv_t<T>;
 
-    using segment_type = device_span<T, L>;
+    using segment_type = remote_span<T, L>;
 
     using size_type = rng::range_size_t<segment_type>;
     using difference_type = rng::range_difference_t<segment_type>;

include/oneapi/dpl/internal/distributed_ranges_impl/shp/distributed_vector.hpp

@@ -11,7 +11,7 @@
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/segments_tools.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/shp/allocators.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/shp/device_ptr.hpp>
-#include <oneapi/dpl/internal/distributed_ranges_impl/shp/device_vector.hpp>
+#include <oneapi/dpl/internal/distributed_ranges_impl/shp/remote_vector.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/shp/vector.hpp>
 
 namespace oneapi::dpl::experimental::dr::shp
@@ -138,8 +138,8 @@ template <typename T, typename Allocator = device_allocator<T>>
 struct distributed_vector
 {
   public:
-    using segment_type = device_vector<T, Allocator>;
-    using const_segment_type = std::add_const_t<device_vector<T, Allocator>>;
+    using segment_type = remote_vector<T, Allocator>;
+    using const_segment_type = std::add_const_t<remote_vector<T, Allocator>>;
 
     using value_type = T;
     using size_type = std::size_t;

include/oneapi/dpl/internal/distributed_ranges_impl/shp/device_span.hpp renamed to include/oneapi/dpl/internal/distributed_ranges_impl/shp/remote_span.hpp

@@ -11,25 +11,25 @@
 namespace oneapi::dpl::experimental::dr::shp
 {
 
-// A `device_span` is simply a normal `std::span` that's
+// A `remote_span` is simply a normal `std::span` that's
 // been decorated with an extra `rank()` function, showing
 // which rank its memory is located on.
 // (Thus fulfilling the `remote_range` concept.)
 /*
 template <class T,
           std::size_t Extent = std::dynamic_extent>
-class device_span : public std::span<T, Extent> {
+class remote_span : public std::span<T, Extent> {
 public:
-  constexpr device_span() noexcept {}
+  constexpr remote_span() noexcept {}
 
   template< class It >
   explicit(Extent != std::dynamic_extent)
-  constexpr device_span(It first, std::size_t count, std::size_t rank)
+  constexpr remote_span(It first, std::size_t count, std::size_t rank)
     : rank_(rank), std::span<T, Extent>(first, count) {}
 
   template< class It, class End >
   explicit(Extent != std::dynamic_extent)
-  constexpr device_span(It first, End last, std::size_t rank)
+  constexpr remote_span(It first, End last, std::size_t rank)
     : rank_(rank), std::span<T, Extent>(first, last) {}
 
   constexpr std::size_t rank() const noexcept {
@@ -42,33 +42,33 @@ class device_span : public std::span<T, Extent> {
 */
 
 template <typename T, typename Iter = T*>
-class device_span : public span<T, Iter>
+class remote_span : public span<T, Iter>
 {
   public:
-    constexpr device_span() noexcept {}
+    constexpr remote_span() noexcept {}
 
     using value_type = T;
     using size_type = std::size_t;
     using difference_type = std::size_t;
     using reference = std::iter_reference_t<Iter>;
 
     template <rng::random_access_range R>
-    requires(remote_range<R>) device_span(R&& r) : span<T, Iter>(rng::begin(r), rng::size(r)), rank_(ranges::rank(r))
+    requires(remote_range<R>) remote_span(R&& r) : span<T, Iter>(rng::begin(r), rng::size(r)), rank_(ranges::rank(r))
     {
     }
 
     template <rng::random_access_range R>
-    device_span(R&& r, std::size_t rank) : span<T, Iter>(rng::begin(r), rng::size(r)), rank_(rank)
+    remote_span(R&& r, std::size_t rank) : span<T, Iter>(rng::begin(r), rng::size(r)), rank_(rank)
     {
     }
 
     template <class It>
-    constexpr device_span(It first, std::size_t count, std::size_t rank) : span<T, Iter>(first, count), rank_(rank)
+    constexpr remote_span(It first, std::size_t count, std::size_t rank) : span<T, Iter>(first, count), rank_(rank)
     {
     }
 
     template <class It, class End>
-    constexpr device_span(It first, End last, std::size_t rank) : span<T, Iter>(first, last), rank_(rank)
+    constexpr remote_span(It first, End last, std::size_t rank) : span<T, Iter>(first, last), rank_(rank)
     {
     }
 
@@ -78,32 +78,32 @@ class device_span : public span<T, Iter>
         return rank_;
     }
 
-    device_span
+    remote_span
     first(std::size_t n) const
     {
-        return device_span(this->begin(), this->begin() + n, rank_);
+        return remote_span(this->begin(), this->begin() + n, rank_);
     }
 
-    device_span
+    remote_span
     last(std::size_t n) const
     {
-        return device_span(this->end() - n, this->end(), rank_);
+        return remote_span(this->end() - n, this->end(), rank_);
     }
 
-    device_span
+    remote_span
     subspan(std::size_t offset, std::size_t count) const
     {
-        return device_span(this->begin() + offset, this->begin() + offset + count, rank_);
+        return remote_span(this->begin() + offset, this->begin() + offset + count, rank_);
     }
 
   private:
     std::size_t rank_;
 };
 
 template <rng::random_access_range R>
-device_span(R&&) -> device_span<rng::range_value_t<R>, rng::iterator_t<R>>;
+remote_span(R&&) -> remote_span<rng::range_value_t<R>, rng::iterator_t<R>>;
 
 template <rng::random_access_range R>
-device_span(R&&, std::size_t) -> device_span<rng::range_value_t<R>, rng::iterator_t<R>>;
+remote_span(R&&, std::size_t) -> remote_span<rng::range_value_t<R>, rng::iterator_t<R>>;
 
 } // namespace oneapi::dpl::experimental::dr::shp

include/oneapi/dpl/internal/distributed_ranges_impl/shp/device_vector.hpp renamed to include/oneapi/dpl/internal/distributed_ranges_impl/shp/remove_vector.hpp

@@ -11,18 +11,18 @@ namespace oneapi::dpl::experimental::dr::shp
 {
 
 template <typename T, typename Allocator>
-class device_vector : public vector<T, Allocator>
+class remote_vector : public vector<T, Allocator>
 {
   public:
-    constexpr device_vector() noexcept {}
+    constexpr remote_vector() noexcept {}
 
     using base = vector<T, Allocator>;
 
     using value_type = T;
     using size_type = std::size_t;
     using difference_type = std::size_t;
 
-    constexpr device_vector(size_type count, const Allocator& alloc, size_type rank) : base(count, alloc), rank_(rank)
+    constexpr remote_vector(size_type count, const Allocator& alloc, size_type rank) : base(count, alloc), rank_(rank)
     {
     }
 
@@ -37,6 +37,6 @@ class device_vector : public vector<T, Allocator>
 };
 
 template <class Alloc>
-device_vector(std::size_t, const Alloc, std::size_t) -> device_vector<typename Alloc::value_type, Alloc>;
+remote_vector(std::size_t, const Alloc, std::size_t) -> remote_vector<typename Alloc::value_type, Alloc>;
 
 } // namespace oneapi::dpl::experimental::dr::shp

include/oneapi/dpl/internal/distributed_ranges_impl/shp/zip_view.hpp

@@ -10,7 +10,7 @@
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/owning_view.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/ranges_shim.hpp>
 #include <oneapi/dpl/internal/distributed_ranges_impl/detail/view_detectors.hpp>
-#include <oneapi/dpl/internal/distributed_ranges_impl/shp/device_span.hpp>
+#include <oneapi/dpl/internal/distributed_ranges_impl/shp/remote_span.hpp>
 
 namespace oneapi::dpl::experimental::dr
 {
@@ -318,7 +318,7 @@ class zip_view : public rng::view_interface<zip_view<Rs...>>
     {
         if constexpr (remote_range<T>)
         {
-            return device_span(std::forward<T>(t));
+            return remote_span(std::forward<T>(t));
         }
         else
         {