Unify handling of list of localities

- rule out case where localities->empty()
STEllAR-GROUP · Dec 29, 2017 · 627b901 · 627b901
1 parent 6e04210
commit 627b901
Show file tree

Hide file tree

Showing 2 changed files with 31 additions and 20 deletions.
diff --git a/hpx/components/containers/container_distribution_policy.hpp b/hpx/components/containers/container_distribution_policy.hpp
@@ -91,7 +91,7 @@ namespace hpx
             return (std::max)(num_parts, std::size_t(1));
         }
 
-        std::vector<hpx::id_type> const& get_localities() const
+        std::vector<hpx::id_type> get_localities() const
         {
             return *this->base_type::ensure_localities();
         }

diff --git a/hpx/runtime/components/default_distribution_policy.hpp b/hpx/runtime/components/default_distribution_policy.hpp
@@ -110,7 +110,7 @@ namespace hpx { namespace components
             auto localities = ensure_localities();
             for (hpx::id_type const& loc: *localities)
             {
-                if (get_num_items(1, loc) != 0)
+                if (get_num_items(localities, 1, loc) != 0)
                 {
                     return stub_base<Component>::create_async(
                         loc, std::forward<Ts>(vs)...);
@@ -156,7 +156,7 @@ namespace hpx { namespace components
                 for (hpx::id_type const& loc: *localities)
                 {
                     objs.push_back(stub_base<Component>::bulk_create_async(
-                        loc, get_num_items(count, loc), vs...));
+                        loc, get_num_items(localities, count, loc), vs...));
                 }
 
                 // consolidate all results
@@ -274,50 +274,55 @@ namespace hpx { namespace components
         ///
         std::size_t get_num_localities() const
         {
-            return (std::max)(std::size_t(1), localities_->size());
+            if (localities_ && localities_->empty())
+            {
+                HPX_THROW_EXCEPTION(invalid_status,
+                    "default_distribution_policy::get_num_localities",
+                    "unexpectedly empty list of localities");
+            }
+            return !localities_ ? std::size_t(1) : localities_->size();
         }
 
         /// Returns the locality which is anticipated to be used for the next
         /// async operation
         hpx::id_type get_next_target() const
         {
-            return (!localities_ || localities_->empty()) ?
-                hpx::find_here() : localities_->front();
+            if (localities_ && localities_->empty())
+            {
+                HPX_THROW_EXCEPTION(invalid_status,
+                    "default_distribution_policy::get_next_target",
+                    "unexpectedly empty list of localities");
+            }
+            return !localities_ ? hpx::find_here() : localities_->front();
         }
 
     protected:
         /// \cond NOINTERNAL
         std::size_t get_num_items(
+            std::shared_ptr<std::vector<id_type>> const& localities,
             std::size_t items, hpx::id_type const& loc) const
         {
             // make sure the given id is known to this distribution policy
             HPX_ASSERT(
-               !localities_ ||
-                (localities_->empty() && loc == hpx::find_here()) ||
-                std::find(localities_->begin(), localities_->end(), loc) !=
-                    localities_->end()
+                std::find(localities->begin(), localities->end(), loc) !=
+                    localities->end()
             );
 
-            if (!localities_ || localities_->empty())
-            {
-                return std::size_t(1);
-            }
-
             // this distribution policy places an equal number of items onto
             // each locality
-            std::size_t locs = (std::max)(std::size_t(1), localities_->size());
+            std::size_t locs = (std::max)(std::size_t(1), localities->size());
 
             // the overall number of items to create is smaller than the number
             // of localities
             if (items < locs)
             {
-                auto it = std::find(localities_->begin(), localities_->end(), loc);
-                std::size_t num_loc = std::distance(localities_->begin(), it);
+                auto it = std::find(localities->begin(), localities->end(), loc);
+                std::size_t num_loc = std::distance(localities->begin(), it);
                 return (items < num_loc) ? 1 : 0;
             }
 
             // the last locality might get less items
-            if (localities_->size() > 1 && loc == localities_->back())
+            if (localities->size() > 1 && loc == localities->back())
             {
                 return items - detail::round_to_multiple(items, locs, locs-1);
             }
@@ -330,11 +335,17 @@ namespace hpx { namespace components
         {
             // use this locality, if this object was default constructed
             auto localities = localities_;
-            if (!localities || localities->empty())
+            if (!localities)
             {
                 localities = std::make_shared<std::vector<id_type>>();
                 localities->push_back(hpx::find_here());
             }
+            if (localities->empty())
+            {
+                HPX_THROW_EXCEPTION(invalid_status,
+                    "default_distribution_policy::ensure_localities",
+                    "unexpectedly empty list of localities");
+            }
             return localities;
         }
         /// \endcond