diff --git a/sycl/CMakeLists.txt b/sycl/CMakeLists.txt
index d540c23ea0a64..d03e65223ac12 100644
--- a/sycl/CMakeLists.txt
+++ b/sycl/CMakeLists.txt
@@ -14,7 +14,7 @@ include(AddSYCLExecutable)
 set(SYCL_MAJOR_VERSION 2)
 set(SYCL_MINOR_VERSION 1)
 set(SYCL_PATCH_VERSION 0)
-set(SYCL_DEV_ABI_VERSION 3)
+set(SYCL_DEV_ABI_VERSION 4)
 if (SYCL_ADD_DEV_VERSION_POSTFIX)
   set(SYCL_VERSION_POSTFIX "-${SYCL_DEV_ABI_VERSION}")
 endif()
diff --git a/sycl/include/CL/sycl.hpp b/sycl/include/CL/sycl.hpp
index 4fd3c55b0952c..2285f9ac63348 100644
--- a/sycl/include/CL/sycl.hpp
+++ b/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>
diff --git a/sycl/include/CL/sycl/accessor.hpp b/sycl/include/CL/sycl/accessor.hpp
index 18084a8a2d2b2..8631cee6ab640 100755
--- a/sycl/include/CL/sycl/accessor.hpp
+++ b/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
diff --git a/sycl/include/CL/sycl/detail/property_helper.hpp b/sycl/include/CL/sycl/detail/property_helper.hpp
new file mode 100644
index 0000000000000..3c8a82bc00117
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/detail/sycl_mem_obj_t.hpp b/sycl/include/CL/sycl/detail/sycl_mem_obj_t.hpp
index 1ab0002cb6d7c..ad795d69806b5 100644
--- a/sycl/include/CL/sycl/detail/sycl_mem_obj_t.hpp
+++ b/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>
 
diff --git a/sycl/include/CL/sycl/properties/accessor_properties.hpp b/sycl/include/CL/sycl/properties/accessor_properties.hpp
new file mode 100644
index 0000000000000..2aea424846ee6
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/properties/buffer_properties.hpp b/sycl/include/CL/sycl/properties/buffer_properties.hpp
new file mode 100644
index 0000000000000..fe83402485d21
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/properties/context_properties.hpp b/sycl/include/CL/sycl/properties/context_properties.hpp
new file mode 100644
index 0000000000000..49ec19890c439
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/properties/image_properties.hpp b/sycl/include/CL/sycl/properties/image_properties.hpp
new file mode 100644
index 0000000000000..ebb7e5d2a2972
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/properties/queue_properties.hpp b/sycl/include/CL/sycl/properties/queue_properties.hpp
new file mode 100644
index 0000000000000..6d596fcf6a67c
--- /dev/null
+++ b/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)
diff --git a/sycl/include/CL/sycl/property_list.hpp b/sycl/include/CL/sycl/property_list.hpp
index b727bf05671c2..5edaa636692f6 100644
--- a/sycl/include/CL/sycl/property_list.hpp
+++ b/sycl/include/CL/sycl/property_list.hpp
@@ -8,332 +8,123 @@
 
 #pragma once
 
-#include <CL/sycl/context.hpp>
 #include <CL/sycl/detail/common.hpp>
-#include <tuple>
+#include <CL/sycl/detail/property_helper.hpp>
+
+#include <bitset>
+#include <memory>
 #include <type_traits>
-#include <utility>
+#include <vector>
 
 __SYCL_INLINE_NAMESPACE(cl) {
 namespace sycl {
 
-// HOW TO ADD NEW PROPERTY INSTRUCTION:
-// 1. Add forward declaration of property class.
-// 2. Add new record in PropKind enum.
-// 3. Use RegisterProp macro passing new record from enum and new class.
-// 4. Add implementation of the new property class using detail::Prop class with
-//    template parameter = new record in enum as a base class.
-
-namespace property {
-
-namespace image {
-class use_host_ptr;
-class use_mutex;
-class context_bound;
-} // namespace image
-
-namespace buffer {
-class use_host_ptr;
-class use_mutex;
-class context_bound;
-} // namespace buffer
-
-namespace queue {
-class enable_profiling;
-class in_order;
-} // namespace queue
-
-class noinit;
-
-namespace detail {
-
-// Will be aliased in the sycl::ext::oneapi::property namespace
-namespace buffer_ {
-class use_pinned_host_memory;
-}
-
-// List of all properties' IDs.
-enum PropKind {
-  // Buffer properties
-  BufferUseHostPtr = 0,
-  BufferContextBound,
-  BufferUseMutex,
-
-  // Image properties
-  ImageUseHostPtr,
-  ImageContextBound,
-  ImageUseMutex,
-
-  // Queue properties
-  QueueEnableProfiling,
-  InOrder,
-
-  // Accessor
-  NoInit,
-
-  BufferUsePinnedHostMemory,
-
-  PropKindSize
-};
-
-// Base class for all properties. Needed to check that user passed only
-// SYCL's properties to property_list c'tor.
-class PropBase {};
+/// Objects of the property_list class are containers for the SYCL properties
+///
+/// \ingroup sycl_api
+class property_list {
 
-// Second base class, needed for mapping PropKind to class and vice versa.
-template <PropKind PropKindT> class Prop;
+  // The structs validate that all objects passed are SYCL properties
+  template <typename... Tail> struct AllProperties : std::true_type {};
+  template <typename T, typename... Tail>
+  struct AllProperties<T, Tail...>
+      : std::conditional<
+            std::is_base_of<detail::DataLessPropertyBase, T>::value ||
+                std::is_base_of<detail::PropertyWithDataBase, T>::value,
+            AllProperties<Tail...>, std::false_type>::type {};
 
-// This class is used in property_list to hold properties.
-template <class T> class PropertyHolder {
 public:
-  PropertyHolder() = default;
-
-  PropertyHolder(const PropertyHolder &P) {
-    if (P.isInitialized()) {
-      new (m_Mem) T(P.getProp());
-      m_Initialized = true;
-    }
-  }
-
-  ~PropertyHolder() {
-    if (m_Initialized) {
-      T *MemPtr = reinterpret_cast<T *>(m_Mem);
-      MemPtr->~T();
-    }
+  template <typename... PropsT, typename = typename std::enable_if<
+                                    AllProperties<PropsT...>::value>::type>
+  property_list(PropsT... Props) : MDataLessProps(false) {
+    ctorHelper(Props...);
   }
 
-  PropertyHolder &operator=(const PropertyHolder &Other) {
-    if (this != &Other) {
-      if (m_Initialized) {
-        T *MemPtr = reinterpret_cast<T *>(m_Mem);
-        MemPtr->~T();
-        m_Initialized = false;
-      }
-
-      if (Other.m_Initialized) {
-        new (m_Mem) T(Other.getProp());
-        m_Initialized = true;
-      }
-    }
-    return *this;
-  }
+  template <typename PropT> PropT get_property() const {
+    if (!has_property<PropT>())
+      throw sycl::invalid_object_error("The property is not found",
+                                       PI_INVALID_VALUE);
 
-  void setProp(const T &Rhs) {
-    new (m_Mem) T(Rhs);
-    m_Initialized = true;
+    return get_property_helper<PropT>();
   }
 
-  const T &getProp() const {
-    assert(true == m_Initialized && "Property was not set!");
-    const T *MemPtr = reinterpret_cast<const T *>(m_Mem);
-    return *MemPtr;
+  template <typename PropT> bool has_property() const {
+    return has_property_helper<PropT>();
   }
-  bool isInitialized() const { return m_Initialized; }
 
 private:
-  // Memory that is used for property allocation
-  alignas(T) unsigned char m_Mem[sizeof(T)];
-  // Indicate whether property initialized or not.
-  bool m_Initialized = false;
-};
+  void ctorHelper() {}
 
-// This macro adds specialization of class Prop which provides possibility to
-// convert PropKind to class and vice versa.
-#define RegisterProp(PropKindT, Type)                                          \
-  template <> class Prop<PropKindT> : public PropBase {                        \
-  public:                                                                      \
-    static constexpr PropKind getKind() { return PropKindT; }                  \
-    using FinalType = Type;                                                    \
+  template <typename... PropsT, class PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::DataLessPropertyBase, PropT>::value>::type
+  ctorHelper(PropT &, PropsT... Props) {
+    const int PropKind = static_cast<int>(PropT::getKind());
+    MDataLessProps[PropKind] = true;
+    ctorHelper(Props...);
   }
 
-// Image
-RegisterProp(PropKind::ImageUseHostPtr, image::use_host_ptr);
-RegisterProp(PropKind::ImageUseMutex, image::use_mutex);
-RegisterProp(PropKind::ImageContextBound, image::context_bound);
-
-// Buffer
-RegisterProp(PropKind::BufferUseHostPtr, buffer::use_host_ptr);
-RegisterProp(PropKind::BufferUseMutex, buffer::use_mutex);
-RegisterProp(PropKind::BufferContextBound, buffer::context_bound);
-RegisterProp(PropKind::BufferUsePinnedHostMemory,
-             buffer_::use_pinned_host_memory);
-
-// Queue
-RegisterProp(PropKind::QueueEnableProfiling, queue::enable_profiling);
-RegisterProp(PropKind::InOrder, queue::in_order);
-
-// Accessor
-RegisterProp(PropKind::NoInit, noinit);
-
-// Sentinel, needed for automatic build of tuple in property_list.
-RegisterProp(PropKind::PropKindSize, PropBase);
-
-// Common class for use_mutex in buffer and image namespaces.
-template <PropKind PropKindT> class UseMutexBase : public Prop<PropKindT> {
-public:
-  UseMutexBase(mutex_class &MutexRef) : m_MutexClass(MutexRef) {}
-  mutex_class *get_mutex_ptr() const { return &m_MutexClass; }
-
-private:
-  mutex_class &m_MutexClass;
-};
-
-// Common class for context_bound in buffer and image namespaces.
-template <PropKind PropKindT> class ContextBoundBase : public Prop<PropKindT> {
-public:
-  ContextBoundBase(cl::sycl::context Context) : m_Context(Context) {}
-  context get_context() const { return m_Context; }
-
-private:
-  cl::sycl::context m_Context;
-};
-} // namespace detail
-
-namespace image {
-
-class use_host_ptr : public detail::Prop<detail::PropKind::ImageUseHostPtr> {};
-
-class use_mutex : public detail::UseMutexBase<detail::PropKind::ImageUseMutex> {
-public:
-  use_mutex(mutex_class &MutexRef) : UseMutexBase(MutexRef) {}
-};
-
-class context_bound
-    : public detail::ContextBoundBase<detail::PropKind::ImageContextBound> {
-public:
-  context_bound(cl::sycl::context Context) : ContextBoundBase(Context) {}
-};
-
-} // namespace image
-
-namespace buffer {
-
-class use_host_ptr : public detail::Prop<detail::PropKind::BufferUseHostPtr> {};
-
-class use_mutex
-    : public detail::UseMutexBase<detail::PropKind::BufferUseMutex> {
-public:
-  use_mutex(mutex_class &MutexRef) : UseMutexBase(MutexRef) {}
-};
-
-class context_bound
-    : public detail::ContextBoundBase<detail::PropKind::BufferContextBound> {
-public:
-  context_bound(cl::sycl::context Context) : ContextBoundBase(Context) {}
-};
-
-} // namespace buffer
-
-namespace detail {
-namespace buffer_ {
-class use_pinned_host_memory
-    : public detail::Prop<detail::PropKind::BufferUsePinnedHostMemory> {};
-} // namespace buffer_
-} // namespace detail
-
-namespace queue {
-class enable_profiling
-    : public detail::Prop<detail::PropKind::QueueEnableProfiling> {};
-
-class in_order : public detail::Prop<detail::PropKind::InOrder> {};
-} // namespace queue
-
-class noinit : public detail::Prop<detail::PropKind::NoInit> {};
-
-} // namespace property
-
-namespace ext {
-namespace oneapi {
-namespace property {
-namespace buffer {
-using use_pinned_host_memory =
-    sycl::property::detail::buffer_::use_pinned_host_memory;
-} // namespace buffer
-} // namespace property
-} // namespace oneapi
-} // namespace ext
-
-#if __cplusplus > 201402L
-
-inline constexpr property::noinit noinit;
-
-#else
-
-namespace {
-
-constexpr const auto &noinit =
-    sycl::detail::InlineVariableHelper<property::noinit>::value;
-
-}
-
-#endif
-
-class property_list {
-
-  // The structs validate that all objects passed are base of PropBase class.
-  template <typename... Tail> struct AllProperties : std::true_type {};
-  template <typename T, typename... Tail>
-  struct AllProperties<T, Tail...>
-      : std::conditional<std::is_base_of<property::detail::PropBase, T>::value,
-                         AllProperties<Tail...>, std::false_type>::type {};
-
-  template <class T>
-  using PropertyHolder = cl::sycl::property::detail::PropertyHolder<T>;
-  template <property::detail::PropKind PropKindT>
-  using Property = cl::sycl::property::detail::Prop<PropKindT>;
-
-  // The structs build tuple type that can hold all properties.
-  template <typename... Head> struct DefineTupleType {
-    using Type = std::tuple<Head...>;
-  };
-
-  template <int Counter, typename... Head>
-  struct BuildTupleType
-      : public std::conditional<
-            (Counter < property::detail::PropKind::PropKindSize),
-            BuildTupleType<
-                Counter + 1, Head...,
-                PropertyHolder<typename Property<(property::detail::PropKind)(
-                    Counter)>::FinalType>>,
-            DefineTupleType<Head...>>::type {};
-
-public:
-  // C'tor initialize m_PropList with properties passed by invoking ctorHelper
-  // recursively
-  template <typename... propertyTN,
-            typename = typename std::enable_if<
-                AllProperties<propertyTN...>::value>::type>
-  property_list(propertyTN... Props) {
+  template <typename... PropsT, class PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::PropertyWithDataBase, PropT>::value>::type
+  ctorHelper(PropT &Prop, PropsT... Props) {
+    MPropsWithData.emplace_back(new PropT(Prop));
     ctorHelper(Props...);
   }
 
-  template <typename propertyT> propertyT get_property() const {
-    if (!has_property<propertyT>()) {
-      throw sycl::invalid_object_error();
-    }
-    const auto &PropHolder =
-        std::get<static_cast<int>(propertyT::getKind())>(m_PropsList);
-    return PropHolder.getProp();
+  template <typename PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::DataLessPropertyBase, PropT>::value, bool>::type
+  has_property_helper() const {
+    const int PropKind = static_cast<int>(PropT::getKind());
+    if (PropKind >= detail::DataLessPropKind::DataLessPropKindSize)
+      return false;
+    return MDataLessProps[PropKind];
   }
 
-  template <typename propertyT> bool has_property() const {
-    if (static_cast<int>(propertyT::getKind()) >
-        property::detail::PropKind::PropKindSize)
-      return false;
-    return std::get<(int)(propertyT::getKind())>(m_PropsList).isInitialized();
+  template <typename PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::PropertyWithDataBase, PropT>::value, bool>::type
+  has_property_helper() const {
+    const int PropKind = static_cast<int>(PropT::getKind());
+    for (const std::shared_ptr<detail::PropertyWithDataBase> &Prop :
+         MPropsWithData)
+      if (Prop->isSame(PropKind))
+        return true;
+    return false;
   }
 
-private:
-  void ctorHelper() {}
+  template <typename PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::DataLessPropertyBase, PropT>::value, PropT>::type
+  get_property_helper() const {
+    // In case of simple property we can just construct it
+    return PropT{};
+  }
 
-  template <typename... propertyTN, class PropT>
-  void ctorHelper(PropT &Prop, propertyTN... props) {
-    std::get<static_cast<int>(PropT::getKind())>(m_PropsList).setProp(Prop);
-    ctorHelper(props...);
+  template <typename PropT>
+  typename std::enable_if<
+      std::is_base_of<detail::PropertyWithDataBase, PropT>::value, PropT>::type
+  get_property_helper() const {
+    const int PropKind = static_cast<int>(PropT::getKind());
+    if (PropKind >= detail::PropWithDataKind::PropWithDataKindSize)
+      throw sycl::invalid_object_error("The property is not found",
+                                       PI_INVALID_VALUE);
+
+    for (const std::shared_ptr<detail::PropertyWithDataBase> &Prop :
+         MPropsWithData)
+      if (Prop->isSame(PropKind))
+        return *static_cast<PropT *>(Prop.get());
+
+    throw sycl::invalid_object_error("The property is not found",
+                                     PI_INVALID_VALUE);
   }
 
-  // Tuple that able to hold all the properties.
-  BuildTupleType<0>::Type m_PropsList;
+private:
+  // Stores enable/not enabled for simple properties
+  std::bitset<detail::DataLessPropKind::DataLessPropKindSize> MDataLessProps;
+  // Stores shared_ptrs to complex properties
+  std::vector<std::shared_ptr<detail::PropertyWithDataBase>> MPropsWithData;
 };
 
 } // namespace sycl
diff --git a/sycl/source/detail/queue_impl.hpp b/sycl/source/detail/queue_impl.hpp
index 5cdcf8c3ee1f8..f3600318cac1b 100644
--- a/sycl/source/detail/queue_impl.hpp
+++ b/sycl/source/detail/queue_impl.hpp
@@ -14,6 +14,8 @@
 #include <CL/sycl/exception.hpp>
 #include <CL/sycl/exception_list.hpp>
 #include <CL/sycl/handler.hpp>
+#include <CL/sycl/properties/context_properties.hpp>
+#include <CL/sycl/properties/queue_properties.hpp>
 #include <CL/sycl/property_list.hpp>
 #include <CL/sycl/stl.hpp>
 #include <detail/context_impl.hpp>
diff --git a/sycl/test/abi/symbol_size.cpp b/sycl/test/abi/symbol_size.cpp
index 40270190afc4f..b6ae3965eda61 100644
--- a/sycl/test/abi/symbol_size.cpp
+++ b/sycl/test/abi/symbol_size.cpp
@@ -54,12 +54,12 @@ int main() {
   check_size<gpu_selector, 8>();
 #ifdef _MSC_VER
   check_size<handler, 552>();
-  check_size<detail::buffer_impl, 288>();
-  check_size<detail::image_impl<1>, 344>();
+  check_size<detail::buffer_impl, 216>();
+  check_size<detail::image_impl<1>, 272>();
 #else
   check_size<handler, 560>();
-  check_size<detail::buffer_impl, 256>();
-  check_size<detail::image_impl<1>, 312>();
+  check_size<detail::buffer_impl, 184>();
+  check_size<detail::image_impl<1>, 240>();
 #endif
   check_size<image<1>, 16>();
   check_size<kernel, 16>();