[SYCL] Rework of SYCL poperties (#2196)

Changed property_list class to support properties of unknown
type. This is achieved by splitting properties to two types:
simple and complex. Simple are those which do not have any
date - just represent that something is enabled or disabled.
Compilex properties have some data.

Simple properties have compile time known id, so they are
always stored in the property_list even if they are not set.
Complex are allocated dynamically and accessed through the
common base class.

Author: romanovvlad

sycl/include/CL/sycl.hpp

@@ -37,6 +37,11 @@
 #include <CL/sycl/platform.hpp>
 #include <CL/sycl/pointers.hpp>
 #include <CL/sycl/program.hpp>
+#include <CL/sycl/properties/accessor_properties.hpp>
+#include <CL/sycl/properties/buffer_properties.hpp>
+#include <CL/sycl/properties/context_properties.hpp>
+#include <CL/sycl/properties/image_properties.hpp>
+#include <CL/sycl/properties/queue_properties.hpp>
 #include <CL/sycl/queue.hpp>
 #include <CL/sycl/range.hpp>
 #include <CL/sycl/sampler.hpp>

sycl/include/CL/sycl/accessor.hpp

@@ -22,6 +22,8 @@
 #include <CL/sycl/id.hpp>
 #include <CL/sycl/image.hpp>
 #include <CL/sycl/pointers.hpp>
+#include <CL/sycl/properties/accessor_properties.hpp>
+#include <CL/sycl/property_list.hpp>
 #include <CL/sycl/sampler.hpp>
 
 /// \file accessor.hpp

sycl/include/CL/sycl/detail/property_helper.hpp

@@ -0,0 +1,83 @@
+//==--------- property_helper.hpp --- SYCL property helper -----------------==//
+//
+// 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>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+namespace detail {
+
+// All properties are split here to dataless properties and properties with
+// data. A dataless property is one which has no data stored in it. A property
+// with data is one which has data stored in it and usually provides and access
+// to it. For dataless property we just store a bool which indicates if a
+// property is set or not. For properties with data we store a pointer to the
+// base class because we do not know the size of such properties beforehand.
+
+// List of all dataless properties' IDs
+enum DataLessPropKind {
+  BufferUseHostPtr = 0,
+  ImageUseHostPtr,
+  QueueEnableProfiling,
+  InOrder,
+  NoInit,
+  BufferUsePinnedHostMemory,
+  UsePrimaryContext,
+  DataLessPropKindSize
+};
+
+// List of all properties with data IDs
+enum PropWithDataKind {
+  BufferUseMutex = 0,
+  BufferContextBound,
+  ImageUseMutex,
+  ImageContextBound,
+  PropWithDataKindSize
+};
+
+// Base class for dataless properties, needed to check that the type of an
+// object passed to the property_list is a property.
+class DataLessPropertyBase {};
+
+// Helper class for the dataless properties. Every such property is supposed
+// to inherit from it. The ID template parameter should be one from
+// DataLessPropKind.
+template <int ID> class DataLessProperty : DataLessPropertyBase {
+public:
+  static constexpr int getKind() { return ID; }
+};
+
+// Base class for properties with data, needed to check that the type of an
+// object passed to the property_list is a property and for checking if two
+// properties with data are of the same type.
+class PropertyWithDataBase {
+public:
+  PropertyWithDataBase(int ID) : MID(ID) {}
+  bool isSame(int ID) const { return ID == MID; }
+  virtual ~PropertyWithDataBase() = default;
+
+private:
+  int MID = -1;
+};
+
+// Helper class for the properties with data. Every such property is supposed
+// to inherit from it. The ID template parameter should be one from
+// PropWithDataKind.
+template <int ID> class PropertyWithData : public PropertyWithDataBase {
+public:
+  PropertyWithData() : PropertyWithDataBase(ID) {}
+  static int getKind() { return ID; }
+};
+
+} // namespace detail
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/detail/sycl_mem_obj_t.hpp

@@ -14,6 +14,8 @@
 #include <CL/sycl/detail/sycl_mem_obj_i.hpp>
 #include <CL/sycl/detail/type_traits.hpp>
 #include <CL/sycl/event.hpp>
+#include <CL/sycl/properties/buffer_properties.hpp>
+#include <CL/sycl/properties/image_properties.hpp>
 #include <CL/sycl/property_list.hpp>
 #include <CL/sycl/stl.hpp>
 

sycl/include/CL/sycl/properties/accessor_properties.hpp

@@ -0,0 +1,37 @@
+//==----------- accessor_properties.hpp --- SYCL accessor properties -------==//
+//
+// 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/property_helper.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace property {
+
+class noinit : public detail::DataLessProperty<detail::NoInit> {};
+
+} // namespace property
+
+#if __cplusplus > 201402L
+
+inline constexpr property::noinit noinit;
+
+#else
+
+namespace {
+
+constexpr const auto &noinit =
+    sycl::detail::InlineVariableHelper<property::noinit>::value;
+}
+
+#endif
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/properties/buffer_properties.hpp

@@ -0,0 +1,57 @@
+//==----------- buffer_properties.hpp --- SYCL buffer properties -----------==//
+//
+// 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/context.hpp>
+#include <CL/sycl/detail/property_helper.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+namespace property {
+namespace buffer {
+class use_host_ptr : public detail::DataLessProperty<detail::BufferUseHostPtr> {
+};
+
+class use_mutex : public detail::PropertyWithData<detail::BufferUseMutex> {
+public:
+  use_mutex(sycl::mutex_class &MutexRef) : MMutex(MutexRef) {}
+
+  sycl::mutex_class *get_mutex_ptr() const { return &MMutex; }
+
+private:
+  sycl::mutex_class &MMutex;
+};
+
+class context_bound
+    : public detail::PropertyWithData<detail::BufferContextBound> {
+public:
+  context_bound(sycl::context BoundContext) : MCtx(std::move(BoundContext)) {}
+
+  context get_context() const { return MCtx; }
+
+private:
+  sycl::context MCtx;
+};
+} // namespace buffer
+} // namespace property
+
+namespace ext {
+namespace oneapi {
+namespace property {
+namespace buffer {
+
+class use_pinned_host_memory
+    : public detail::DataLessProperty<detail::BufferUsePinnedHostMemory> {};
+} // namespace buffer
+} // namespace property
+} // namespace oneapi
+} // namespace ext
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/properties/context_properties.hpp

@@ -0,0 +1,25 @@
+//==----------- context_properties.hpp --- SYCL context properties ---------==//
+//
+// 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/context.hpp>
+#include <CL/sycl/detail/property_helper.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace property {
+namespace context {
+namespace cuda {
+class use_primary_context
+    : public detail::DataLessProperty<detail::UsePrimaryContext> {};
+} // namespace cuda
+} // namespace context
+} // namespace property
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/properties/image_properties.hpp

@@ -0,0 +1,44 @@
+//==----------- image_properties.hpp --- SYCL image properties -------------==//
+//
+// 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/context.hpp>
+#include <CL/sycl/detail/property_helper.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace property {
+namespace image {
+class use_host_ptr : public detail::DataLessProperty<detail::ImageUseHostPtr> {
+};
+
+class use_mutex : public detail::PropertyWithData<detail::ImageUseMutex> {
+public:
+  use_mutex(sycl::mutex_class &MutexRef) : MMutex(MutexRef) {}
+
+  sycl::mutex_class *get_mutex_ptr() const { return &MMutex; }
+
+private:
+  sycl::mutex_class &MMutex;
+};
+
+class context_bound
+    : public detail::PropertyWithData<detail::ImageContextBound> {
+public:
+  context_bound(sycl::context BoundContext) : MCtx(std::move(BoundContext)) {}
+
+  context get_context() const { return MCtx; }
+
+private:
+  sycl::context MCtx;
+};
+} // namespace image
+} // namespace property
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/properties/queue_properties.hpp

@@ -0,0 +1,23 @@
+//==----------- queue_properties.hpp --- SYCL queue properties -------------==//
+//
+// 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/property_helper.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+namespace property {
+namespace queue {
+class in_order : public detail::DataLessProperty<detail::InOrder> {};
+class enable_profiling
+    : public detail::DataLessProperty<detail::QueueEnableProfiling> {};
+} // namespace queue
+} // namespace property
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)