[SYCL][NFC] Rename Adapter class to adapter_impl

Author: uditagarwal97

sycl/source/detail/adapter.hpp

@@ -42,11 +42,11 @@ namespace detail {
 /// runtimes for the device-agnostic SYCL runtime.
 ///
 /// \ingroup sycl_ur
-class Adapter {
+class adapter_impl {
 public:
-  Adapter() = delete;
+  adapter_impl() = delete;
 
-  Adapter(ur_adapter_handle_t adapter, backend UseBackend)
+  adapter_impl(ur_adapter_handle_t adapter, backend UseBackend)
       : MAdapter(adapter), MBackend(UseBackend),
         MAdapterMutex(std::make_shared<std::mutex>()) {
 
@@ -57,12 +57,12 @@ class Adapter {
   }
 
   // Disallow accidental copies of adapters
-  Adapter &operator=(const Adapter &) = delete;
-  Adapter(const Adapter &) = delete;
-  Adapter &operator=(Adapter &&other) noexcept = delete;
-  Adapter(Adapter &&other) noexcept = delete;
+  adapter_impl &operator=(const adapter_impl &) = delete;
+  adapter_impl(const adapter_impl &) = delete;
+  adapter_impl &operator=(adapter_impl &&other) noexcept = delete;
+  adapter_impl(adapter_impl &&other) noexcept = delete;
 
-  ~Adapter() = default;
+  ~adapter_impl() = default;
 
   /// \throw SYCL 2020 exception(errc) if ur_result is not UR_RESULT_SUCCESS
   template <sycl::errc errc = sycl::errc::runtime>
@@ -237,7 +237,7 @@ class Adapter {
   void *UrLoaderHandle = nullptr;
 #endif
   UrFuncPtrMapT UrFuncPtrs;
-}; // class Adapter
+}; // class adapter_impl
 
 } // namespace detail
 } // namespace _V1

sycl/source/detail/event_impl.hpp

@@ -27,7 +27,7 @@ class graph_impl;
 }
 class context;
 namespace detail {
-class Adapter;
+class adapter_impl;
 class context_impl;
 using ContextImplPtr = std::shared_ptr<sycl::detail::context_impl>;
 class queue_impl;

sycl/source/detail/global_handler.cpp

@@ -230,8 +230,8 @@ std::mutex &GlobalHandler::getFilterMutex() {
   return FilterMutex;
 }
 
-std::vector<Adapter *> &GlobalHandler::getAdapters() {
-  static std::vector<Adapter *> &adapters = getOrCreate(MAdapters);
+std::vector<adapter_impl *> &GlobalHandler::getAdapters() {
+  static std::vector<adapter_impl *> &adapters = getOrCreate(MAdapters);
   enableOnCrashStackPrinting();
   return adapters;
 }

sycl/source/detail/global_handler.hpp

@@ -23,7 +23,7 @@ class context_impl;
 class Scheduler;
 class ProgramManager;
 class Sync;
-class Adapter;
+class adapter_impl;
 class ods_target_list;
 class XPTIRegistry;
 class ThreadPool;
@@ -70,7 +70,7 @@ class GlobalHandler {
   std::mutex &getPlatformToDefaultContextCacheMutex();
   std::mutex &getPlatformMapMutex();
   std::mutex &getFilterMutex();
-  std::vector<Adapter *> &getAdapters();
+  std::vector<adapter_impl *> &getAdapters();
   ods_target_list &getOneapiDeviceSelectorTargets(const std::string &InitValue);
   XPTIRegistry &getXPTIRegistry();
   ThreadPool &getHostTaskThreadPool();
@@ -125,7 +125,7 @@ class GlobalHandler {
   InstWithLock<std::mutex> MPlatformToDefaultContextCacheMutex;
   InstWithLock<std::mutex> MPlatformMapMutex;
   InstWithLock<std::mutex> MFilterMutex;
-  InstWithLock<std::vector<Adapter *>> MAdapters;
+  InstWithLock<std::vector<adapter_impl *>> MAdapters;
   InstWithLock<ods_target_list> MOneapiDeviceSelectorTargets;
   InstWithLock<XPTIRegistry> MXPTIRegistry;
   // Thread pool for host task and event callbacks execution

sycl/source/detail/kernel_name_based_cache_t.hpp

@@ -29,15 +29,15 @@ struct FastKernelCacheVal {
   const KernelArgMask *MKernelArgMask; /* Eliminated kernel argument mask. */
   ur_program_handle_t MProgramHandle;  /* UR program handle corresponding to
                                      this kernel. */
-  const Adapter &MAdapterPtr;          /* We can keep reference to the adapter
+  const adapter_impl &MAdapterPtr;          /* We can keep reference to the adapter
                                      because during 2-stage shutdown the kernel
                                      cache is destroyed deliberately before the
                                      adapter. */
 
   FastKernelCacheVal(ur_kernel_handle_t KernelHandle, std::mutex *Mutex,
                      const KernelArgMask *KernelArgMask,
                      ur_program_handle_t ProgramHandle,
-                     const Adapter &AdapterPtr)
+                     const adapter_impl &AdapterPtr)
       : MKernelHandle(KernelHandle), MMutex(Mutex),
         MKernelArgMask(KernelArgMask), MProgramHandle(ProgramHandle),
         MAdapterPtr(AdapterPtr) {}

sycl/source/detail/platform_impl.cpp

@@ -172,21 +172,23 @@ std::vector<platform> platform_impl::get_platforms() {
   std::vector<std::pair<platform, AdapterPtr>> PlatformsWithAdapter;
 
   // Then check backend-specific adapters
+  std::vector<platform> Platforms;
   for (auto &Adapter : Adapters) {
     const auto &AdapterPlatforms = getAdapterPlatforms(Adapter);
     for (const auto &P : AdapterPlatforms) {
+      Platforms.push_back(P);
       PlatformsWithAdapter.push_back({P, Adapter});
     }
   }
 
   // For the selected platforms register them with their adapters
-  std::vector<platform> Platforms;
-  for (auto &Platform : PlatformsWithAdapter) {
-    auto &Adapter = Platform.second;
-    std::lock_guard<std::mutex> Guard(*Adapter->getAdapterMutex());
-    Adapter->getPlatformId(getSyclObjImpl(Platform.first)->getHandleRef());
-    Platforms.push_back(Platform.first);
-  }
+  // std::vector<platform> Platforms;
+  // for (auto &Platform : PlatformsWithAdapter) {
+  //   auto &Adapter = Platform.second;
+  //   std::lock_guard<std::mutex> Guard(*Adapter->getAdapterMutex());
+  //   Adapter->getPlatformId(getSyclObjImpl(Platform.first)->getHandleRef());
+  //   Platforms.push_back(Platform.first);
+  // }
 
   // This initializes a function-local variable whose destructor is invoked as
   // the SYCL shared library is first being unloaded.

sycl/source/detail/platform_impl.hpp

@@ -39,7 +39,7 @@ class platform_impl : public std::enable_shared_from_this<platform_impl> {
   //
   // Platforms can only be created under `GlobalHandler`'s ownership via
   // `platform_impl::getOrMakePlatformImpl` method.
-  explicit platform_impl(ur_platform_handle_t APlatform, Adapter *AAdapter)
+  explicit platform_impl(ur_platform_handle_t APlatform, adapter_impl *AAdapter)
       : MPlatform(APlatform), MAdapter(AAdapter) {
     // Find out backend of the platform
     ur_backend_t UrBackend = UR_BACKEND_UNKNOWN;

sycl/source/detail/sycl_mem_obj_t.hpp

@@ -33,8 +33,8 @@ namespace detail {
 // Forward declarations
 class context_impl;
 class event_impl;
-class Adapter;
-using AdapterPtr = Adapter *;
+class adapter_impl;
+using AdapterPtr = adapter_impl *;
 
 using EventImplPtr = std::shared_ptr<event_impl>;
 

sycl/source/detail/ur.cpp

@@ -90,7 +90,7 @@ bool trace(TraceLevel Level) {
   return (TraceLevelMask & Level) == Level;
 }
 
-static void initializeAdapters(std::vector<Adapter *> &Adapters,
+static void initializeAdapters(std::vector<adapter_impl *> &Adapters,
                                ur_loader_config_handle_t LoaderConfig);
 
 bool XPTIInitDone = false;
@@ -117,7 +117,7 @@ std::vector<AdapterPtr> &initializeUr(ur_loader_config_handle_t LoaderConfig) {
   return GlobalHandler::instance().getAdapters();
 }
 
-static void initializeAdapters(std::vector<Adapter *> &Adapters,
+static void initializeAdapters(std::vector<adapter_impl *> &Adapters,
                                ur_loader_config_handle_t LoaderConfig) {
 #define CHECK_UR_SUCCESS(Call)                                                 \
   {                                                                            \
@@ -238,7 +238,7 @@ static void initializeAdapters(std::vector<Adapter *> &Adapters,
                                     sizeof(adapterBackend), &adapterBackend,
                                     nullptr));
     auto syclBackend = UrToSyclBackend(adapterBackend);
-    Adapters.emplace_back(new Adapter(UrAdapter, syclBackend));
+    Adapters.emplace_back(new adapter_impl(UrAdapter, syclBackend));
 
     const char *env_value = std::getenv("UR_LOG_CALLBACK");
     if (env_value == nullptr || std::string(env_value) != "disabled") {

sycl/source/detail/ur.hpp

@@ -24,8 +24,8 @@ namespace sycl {
 inline namespace _V1 {
 enum class backend : char;
 namespace detail {
-class Adapter;
-using AdapterPtr = Adapter *;
+class adapter_impl;
+using AdapterPtr = adapter_impl *;
 
 namespace ur {
 void *getURLoaderLibrary();