platform_impl.hpp

Go to the documentation of this file.

//==-------------- platform_impl.hpp - SYCL platform -----------------------==//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#pragma once
 
#include <detail/platform_info.hpp>
#include <detail/plugin.hpp>
#include <sycl/backend.hpp>
#include <sycl/backend_types.hpp>
#include <sycl/detail/cl.h>
#include <sycl/detail/common.hpp>
#include <sycl/detail/pi.hpp>
#include <sycl/info/info_desc.hpp>
 
namespace sycl {
inline namespace _V1 {
 
// Forward declaration
class device_selector;
class device;
enum class aspect;
 
namespace detail {
class device_impl;
 
// TODO: implement extension management for host device
// TODO: implement parameters treatment for host device
class platform_impl {
public:
  platform_impl() : MHostPlatform(true) {}
 
  explicit platform_impl(sycl::detail::pi::PiPlatform APlatform,
                         const std::shared_ptr<plugin> &APlugin)
      : MPlatform(APlatform), MPlugin(APlugin) {
 
    // Find out backend of the platform
    sycl::detail::pi::PiPlatformBackend PiBackend;
    APlugin->call_nocheck<PiApiKind::piPlatformGetInfo>(
        APlatform, PI_EXT_PLATFORM_INFO_BACKEND,
        sizeof(sycl::detail::pi::PiPlatformBackend), &PiBackend, nullptr);
    MBackend = convertBackend(PiBackend);
  }
 
  ~platform_impl() = default;
 
  bool has_extension(const std::string &ExtensionName) const;
 
  bool supports_usm() const;
 
  std::vector<device>
  get_devices(info::device_type DeviceType = info::device_type::all) const;
 
  template <typename Param> typename Param::return_type get_info() const;
 
  template <typename Param>
  typename Param::return_type get_backend_info() const;
 
  bool is_host() const { return MHostPlatform; };
 
  backend getBackend(void) const { return MBackend; }
 
  void getBackendOption(const char *frontend_option,
                        const char **backend_option) const {
    const auto &Plugin = getPlugin();
    sycl::detail::pi::PiResult Err =
        Plugin->call_nocheck<PiApiKind::piPluginGetBackendOption>(
            MPlatform, frontend_option, backend_option);
    Plugin->checkPiResult(Err);
  }
 
  cl_platform_id get() const {
    if (is_host()) {
      throw invalid_object_error(
          "This instance of platform doesn't support OpenCL interoperability.",
          PI_ERROR_INVALID_PLATFORM);
    }
    return pi::cast<cl_platform_id>(MPlatform);
  }
 
  const sycl::detail::pi::PiPlatform &getHandleRef() const {
    if (is_host())
      throw invalid_object_error("This instance of platform is a host instance",
                                 PI_ERROR_INVALID_PLATFORM);
 
    return MPlatform;
  }
 
  static std::vector<platform> get_platforms();
 
  // \return the Plugin associated with this platform.
  const PluginPtr &getPlugin() const {
    assert(!MHostPlatform && "Plugin is not available for Host.");
    return MPlugin;
  }
 
  void setPlugin(PluginPtr &PluginPtr, backend Backend) {
    assert(!MHostPlatform && "Plugin is not available for Host");
    MPlugin = PluginPtr;
    MBackend = Backend;
  }
 
  pi_native_handle getNative() const;
 
  bool has(aspect Aspect) const;
 
  std::shared_ptr<device_impl>
  getDeviceImpl(sycl::detail::pi::PiDevice PiDevice);
 
  std::shared_ptr<device_impl>
  getOrMakeDeviceImpl(sycl::detail::pi::PiDevice PiDevice,
                      const std::shared_ptr<platform_impl> &PlatformImpl);
 
 
  static std::shared_ptr<platform_impl> getHostPlatformImpl();
 
  static std::shared_ptr<platform_impl>
  getOrMakePlatformImpl(sycl::detail::pi::PiPlatform PiPlatform,
                        const PluginPtr &Plugin);
 
  static std::shared_ptr<platform_impl>
  getPlatformFromPiDevice(sycl::detail::pi::PiDevice PiDevice,
                          const PluginPtr &Plugin);
 
  // when getting sub-devices for ONEAPI_DEVICE_SELECTOR we may temporarily
  // ensure every device is a root one.
  bool MAlwaysRootDevice = false;
 
private:
  std::shared_ptr<device_impl>
  getDeviceImplHelper(sycl::detail::pi::PiDevice PiDevice);
 
  // Helper to filter reportable devices in the platform
  template <typename ListT, typename FilterT>
  std::vector<int>
  filterDeviceFilter(std::vector<sycl::detail::pi::PiDevice> &PiDevices,
                     ListT *FilterList) const;
 
  bool MHostPlatform = false;
  sycl::detail::pi::PiPlatform MPlatform = 0;
  backend MBackend;
 
  PluginPtr MPlugin;
  std::vector<std::weak_ptr<device_impl>> MDeviceCache;
  std::mutex MDeviceMapMutex;
};
 
} // namespace detail
} // namespace _V1
} // namespace sycl