[NFC][SYCL] Add device_images_range helper

aelovikov-intel · aelovikov-intel · commit 06f765f73d8e · 2025-07-17T12:34:15.000-07:00
diff --git a/sycl/source/detail/device_image_impl.hpp b/sycl/source/detail/device_image_impl.hpp
@@ -1338,6 +1338,17 @@ class device_image_impl
   std::unique_ptr<DynRTDeviceBinaryImage> MMergedImageStorage = nullptr;
 };
 
+using device_images_iterator =
+    variadic_iterator<device_image_plain,
+                      std::vector<device_image_plain>::const_iterator>;
+class device_images_range : public iterator_range<device_images_iterator> {
+private:
+  using Base = iterator_range<device_images_iterator>;
+
+public:
+  using Base::Base;
+};
+
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/source/detail/helpers.hpp b/sycl/source/detail/helpers.hpp
@@ -90,6 +90,8 @@ template <typename SyclTy, typename... Iterators> class variadic_iterator {
         },
         It);
   }
+
+  pointer operator->() { return &this->operator*(); }
 };
 
 // Non-owning!
@@ -175,6 +177,21 @@ template <typename iterator> class iterator_range {
   iterator End;
   const size_t Size;
 };
+
+template <typename iterator, class Pred>
+bool all_of(iterator_range<iterator> R, Pred &&P) {
+  return std::all_of(R.begin(), R.end(), std::forward<Pred>(P));
+}
+
+template <typename iterator, class Pred>
+bool any_of(iterator_range<iterator> R, Pred &&P) {
+  return std::any_of(R.begin(), R.end(), std::forward<Pred>(P));
+}
+
+template <typename iterator, class Pred>
+bool none_of(iterator_range<iterator> R, Pred &&P) {
+  return std::none_of(R.begin(), R.end(), std::forward<Pred>(P));
+}
 } // namespace detail
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/source/detail/kernel_bundle_impl.hpp b/sycl/source/detail/kernel_bundle_impl.hpp
@@ -504,8 +504,7 @@ class kernel_bundle_impl
 
     if (get_bundle_state() == bundle_state::input) {
       // Copy spec constants values from the device images.
-      auto MergeSpecConstants = [this](const device_image_plain &Img) {
-        detail::device_image_impl &ImgImpl = *getSyclObjImpl(Img);
+      for (detail::device_image_impl &ImgImpl : device_images()) {
         const std::map<std::string,
                        std::vector<device_image_impl::SpecConstDescT>>
             &SpecConsts = ImgImpl.get_spec_const_data_ref();
@@ -521,8 +520,7 @@ class kernel_bundle_impl
                 SpecConst.second.back().CompositeOffset +
                     SpecConst.second.back().Size);
         }
-      };
-      std::for_each(begin(), end(), MergeSpecConstants);
+      }
     }
 
     for (const detail::KernelBundleImplPtr &Bundle : Bundles) {
@@ -667,10 +665,9 @@ class kernel_bundle_impl
 
 public:
   bool ext_oneapi_has_kernel(const std::string &Name) const {
-    return std::any_of(begin(), end(),
-                       [&Name](const device_image_plain &DevImg) {
-                         return getSyclObjImpl(DevImg)->hasKernelName(Name);
-                       });
+    return any_of(device_images(), [&Name](device_image_impl &DevImg) {
+      return DevImg.hasKernelName(Name);
+    });
   }
 
   kernel ext_oneapi_get_kernel(const std::string &Name) const {
@@ -705,25 +702,24 @@ class kernel_bundle_impl
                             "files and kernel_bundles successfully built from "
                             "kernel_bundle<bundle_state::ext_oneapi_source>.");
 
-    auto It =
-        std::find_if(begin(), end(), [&Name](const device_image_plain &DevImg) {
-          return getSyclObjImpl(DevImg)->hasKernelName(Name);
-        });
-    if (It == end())
+    auto It = std::find_if(device_images().begin(), device_images().end(),
+                           [&Name](device_image_impl &DevImg) {
+                             return DevImg.hasKernelName(Name);
+                           });
+    if (It == device_images().end())
       throw sycl::exception(make_error_code(errc::invalid),
                             "kernel '" + Name + "' not found in kernel_bundle");
 
-    return getSyclObjImpl(*It)->adjustKernelName(Name);
+    return It->adjustKernelName(Name);
   }
 
   bool ext_oneapi_has_device_global(const std::string &Name) const {
     std::string MangledName = mangleDeviceGlobalName(Name);
     return (MDeviceGlobals.size() &&
             MDeviceGlobals.tryGetEntryLockless(MangledName)) ||
-           std::any_of(begin(), end(),
-                       [&MangledName](const device_image_plain &DeviceImage) {
-                         return getSyclObjImpl(DeviceImage)
-                             ->hasDeviceGlobalName(MangledName);
+           std::any_of(device_images().begin(), device_images().end(),
+                       [&MangledName](device_image_impl &DeviceImage) {
+                         return DeviceImage.hasDeviceGlobalName(MangledName);
                        });
   }
 
@@ -803,51 +799,43 @@ class kernel_bundle_impl
   }
 
   bool has_kernel(const kernel_id &KernelID) const noexcept {
-    return std::any_of(begin(), end(),
-                       [&KernelID](const device_image_plain &DeviceImage) {
-                         return DeviceImage.has_kernel(KernelID);
-                       });
+    return any_of(device_images(), [&KernelID](device_image_impl &DeviceImage) {
+      return DeviceImage.has_kernel(KernelID);
+    });
   }
 
   bool has_kernel(const kernel_id &KernelID, const device &Dev) const noexcept {
-    return std::any_of(
-        begin(), end(),
-        [&KernelID, &Dev](const device_image_plain &DeviceImage) {
-          return DeviceImage.has_kernel(KernelID, Dev);
-        });
+    return any_of(device_images(),
+                  [&KernelID, &Dev](device_image_impl &DeviceImage) {
+                    return DeviceImage.has_kernel(KernelID, Dev);
+                  });
   }
 
   bool contains_specialization_constants() const noexcept {
-    return std::any_of(
-        begin(), end(), [](const device_image_plain &DeviceImage) {
-          return getSyclObjImpl(DeviceImage)->has_specialization_constants();
-        });
+    return any_of(device_images(), [](device_image_impl &DeviceImage) {
+      return DeviceImage.has_specialization_constants();
+    });
   }
 
   bool native_specialization_constant() const noexcept {
     return contains_specialization_constants() &&
-           std::all_of(begin(), end(),
-                       [](const device_image_plain &DeviceImage) {
-                         return getSyclObjImpl(DeviceImage)
-                             ->all_specialization_constant_native();
-                       });
+           all_of(device_images(), [](device_image_impl &DeviceImage) {
+             return DeviceImage.all_specialization_constant_native();
+           });
   }
 
   bool has_specialization_constant(const char *SpecName) const noexcept {
-    return std::any_of(begin(), end(),
-                       [SpecName](const device_image_plain &DeviceImage) {
-                         return getSyclObjImpl(DeviceImage)
-                             ->has_specialization_constant(SpecName);
-                       });
+    return any_of(device_images(), [SpecName](device_image_impl &DeviceImage) {
+      return DeviceImage.has_specialization_constant(SpecName);
+    });
   }
 
   void set_specialization_constant_raw_value(const char *SpecName,
                                              const void *Value,
                                              size_t Size) noexcept {
     if (has_specialization_constant(SpecName))
-      for (const device_image_plain &DeviceImage : MUniqueDeviceImages)
-        getSyclObjImpl(DeviceImage)
-            ->set_specialization_constant_raw_value(SpecName, Value);
+      for (device_image_impl &DeviceImage : device_images())
+        DeviceImage.set_specialization_constant_raw_value(SpecName, Value);
     else {
       std::vector<unsigned char> &Val = MSpecConstValues[std::string{SpecName}];
       Val.resize(Size);
@@ -857,10 +845,9 @@ class kernel_bundle_impl
 
   void get_specialization_constant_raw_value(const char *SpecName,
                                              void *ValueRet) const noexcept {
-    for (const device_image_plain &DeviceImage : MUniqueDeviceImages)
-      if (getSyclObjImpl(DeviceImage)->has_specialization_constant(SpecName)) {
-        getSyclObjImpl(DeviceImage)
-            ->get_specialization_constant_raw_value(SpecName, ValueRet);
+    for (device_image_impl &DeviceImage : device_images())
+      if (DeviceImage.has_specialization_constant(SpecName)) {
+        DeviceImage.get_specialization_constant_raw_value(SpecName, ValueRet);
         return;
       }
 
@@ -879,19 +866,21 @@ class kernel_bundle_impl
   }
 
   bool is_specialization_constant_set(const char *SpecName) const noexcept {
-    bool SetInDevImg = std::any_of(
-        begin(), end(), [SpecName](const device_image_plain &DeviceImage) {
-          return getSyclObjImpl(DeviceImage)
-              ->is_specialization_constant_set(SpecName);
+    bool SetInDevImg =
+        any_of(device_images(), [SpecName](device_image_impl &DeviceImage) {
+          return DeviceImage.is_specialization_constant_set(SpecName);
         });
     return SetInDevImg || MSpecConstValues.count(std::string{SpecName}) != 0;
   }
 
+  // Don't use these two for code under `source/detail`, they are only needed to
+  // communicate across DSO boundary.
   const device_image_plain *begin() const { return MUniqueDeviceImages.data(); }
-
   const device_image_plain *end() const {
     return MUniqueDeviceImages.data() + MUniqueDeviceImages.size();
   }
+  // ...use that instead.
+  device_images_range device_images() const { return MUniqueDeviceImages; }
 
   size_t size() const noexcept { return MUniqueDeviceImages.size(); }
 
@@ -931,28 +920,26 @@ class kernel_bundle_impl
   }
 
   bool hasSourceBasedImages() const noexcept {
-    return std::any_of(begin(), end(), [](const device_image_plain &DevImg) {
-      return getSyclObjImpl(DevImg)->getOriginMask() &
-             ImageOriginKernelCompiler;
+    return any_of(device_images(), [](device_image_impl &DevImg) {
+      return DevImg.getOriginMask() & ImageOriginKernelCompiler;
     });
   }
 
   bool hasSYCLBINImages() const noexcept {
-    return std::any_of(begin(), end(), [](const device_image_plain &DevImg) {
-      return getSyclObjImpl(DevImg)->getOriginMask() & ImageOriginSYCLBIN;
+    return any_of(device_images(), [](device_image_impl &DevImg) {
+      return DevImg.getOriginMask() & ImageOriginSYCLBIN;
     });
   }
 
   bool hasSYCLOfflineImages() const noexcept {
-    return std::any_of(begin(), end(), [](const device_image_plain &DevImg) {
-      return getSyclObjImpl(DevImg)->getOriginMask() & ImageOriginSYCLOffline;
+    return any_of(device_images(), [](device_image_impl &DevImg) {
+      return DevImg.getOriginMask() & ImageOriginSYCLOffline;
     });
   }
 
   bool allSourceBasedImages() const noexcept {
-    return std::all_of(begin(), end(), [](const device_image_plain &DevImg) {
-      return getSyclObjImpl(DevImg)->getOriginMask() &
-             ImageOriginKernelCompiler;
+    return all_of(device_images(), [](device_image_impl &DevImg) {
+      return DevImg.getOriginMask() & ImageOriginKernelCompiler;
     });
   }
 
