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 <CL/sycl/detail/common.hpp>
#include <CL/sycl/detail/pi.hpp>
#include <CL/sycl/info/info_desc.hpp>
#include <CL/sycl/stl.hpp>
#include <detail/platform_info.hpp>
#include <detail/plugin.hpp>
 
__SYCL_INLINE_NAMESPACE(cl) {
namespace sycl {
 
// 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(RT::PiPlatform APlatform, const plugin &APlugin)
      : MPlatform(APlatform), MPlugin(std::make_shared<plugin>(APlugin)) {}
 
  explicit platform_impl(RT::PiPlatform APlatform,
                         std::shared_ptr<plugin> APlugin)
      : MPlatform(APlatform), MPlugin(APlugin) {}
 
  ~platform_impl() = default;
 
  bool has_extension(const std::string &ExtensionName) const;
 
  std::vector<device>
  get_devices(info::device_type DeviceType = info::device_type::all) const;
 
  template <info::platform param>
  typename info::param_traits<info::platform, param>::return_type
  get_info() const;
 
  bool is_host() const { return MHostPlatform; };
 
  cl_platform_id get() const {
    if (is_host()) {
      throw invalid_object_error(
          "This instance of platform doesn't support OpenCL interoperability.",
          PI_INVALID_PLATFORM);
    }
    return pi::cast<cl_platform_id>(MPlatform);
  }
 
  const RT::PiPlatform &getHandleRef() const {
    if (is_host())
      throw invalid_object_error("This instance of platform is a host instance",
                                 PI_INVALID_PLATFORM);
 
    return MPlatform;
  }
 
  static std::vector<platform> get_platforms();
 
  // \return the Plugin associated with this platform.
  const plugin &getPlugin() const {
    assert(!MHostPlatform && "Plugin is not available for Host.");
    return *MPlugin;
  }
 
  void setPlugin(std::shared_ptr<plugin> PluginPtr) {
    assert(!MHostPlatform && "Plugin is not available for Host");
    MPlugin = std::move(PluginPtr);
  }
 
  pi_native_handle getNative() const;
 
  bool has(aspect Aspect) const;
 
  std::shared_ptr<device_impl>
  getOrMakeDeviceImpl(RT::PiDevice PiDevice,
                      const std::shared_ptr<platform_impl> &PlatformImpl);
 
 
  static std::shared_ptr<platform_impl> getHostPlatformImpl();
 
  static std::shared_ptr<platform_impl>
  getOrMakePlatformImpl(RT::PiPlatform PiPlatform, const plugin &Plugin);
 
  static std::shared_ptr<platform_impl>
  getPlatformFromPiDevice(RT::PiDevice PiDevice, const plugin &Plugin);
 
private:
  bool MHostPlatform = false;
  RT::PiPlatform MPlatform = 0;
  std::shared_ptr<plugin> MPlugin;
  std::vector<std::weak_ptr<device_impl>> MDeviceCache;
  std::mutex MDeviceMapMutex;
};
 
} // namespace detail
} // namespace sycl
} // __SYCL_INLINE_NAMESPACE(cl)