Move device properties inside QueueRegistry

sbaldu · sbaldu · commit e49e604eee7f · 2025-04-09T17:48:00.000+02:00
diff --git a/include/alpaka/dev/DevCpu.hpp b/include/alpaka/dev/DevCpu.hpp
@@ -6,7 +6,6 @@
 #pragma once
 
 #include "alpaka/dev/Traits.hpp"
-#include "alpaka/dev/common/DeviceProperties.hpp"
 #include "alpaka/dev/common/QueueRegistry.hpp"
 #include "alpaka/dev/cpu/SysInfo.hpp"
 #include "alpaka/mem/buf/Traits.hpp"
@@ -58,10 +57,7 @@ namespace alpaka
         friend struct trait::GetDevByIdx<PlatformCpu>;
 
     protected:
-        DevCpu()
-            : m_spDevCpuImpl(std::make_shared<cpu::detail::DevCpuImpl>())
-            , m_deviceProperties(std::make_shared<alpaka::DeviceProperties>())
-            , m_mutex(std::make_shared<std::mutex>())
+        DevCpu() : m_spDevCpuImpl(std::make_shared<cpu::detail::DevCpuImpl>())
         {
         }
 
@@ -101,8 +97,6 @@ namespace alpaka
 
     private:
         std::shared_ptr<cpu::detail::DevCpuImpl> m_spDevCpuImpl;
-        std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;
-        std::shared_ptr<std::mutex> m_mutex;
     };
 
     namespace trait
@@ -114,13 +108,13 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getName(DevCpu const& dev) -> std::string
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->name.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_spDevCpuImpl->mutex());
+                    if(!dev.m_spDevCpuImpl->deviceProperties().name.has_value())
                     {
-                        dev.m_deviceProperties->name = cpu::detail::getCpuName();
+                        dev.m_spDevCpuImpl->deviceProperties().name = cpu::detail::getCpuName();
                     }
                 }
-                return dev.m_deviceProperties->name.value();
+                return dev.m_spDevCpuImpl->deviceProperties().name.value();
             }
         };
 
@@ -131,30 +125,24 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getMemBytes(DevCpu const& dev) -> std::size_t
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->totalGlobalMem.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_spDevCpuImpl->mutex());
+                    if(!dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem.has_value())
                     {
-                        dev.m_deviceProperties->totalGlobalMem = cpu::detail::getTotalGlobalMemSizeBytes();
+                        dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem
+                            = cpu::detail::getTotalGlobalMemSizeBytes();
                     }
                 }
-                return dev.m_deviceProperties->totalGlobalMem.value();
+                return dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem.value();
             }
         };
 
         //! The CPU device free memory get trait specialization.
         template<>
         struct GetFreeMemBytes<DevCpu>
         {
-            ALPAKA_FN_HOST static auto getFreeMemBytes(DevCpu const& dev) -> std::size_t
+            ALPAKA_FN_HOST static auto getFreeMemBytes(DevCpu const& /* dev */) -> std::size_t
             {
-                {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->freeGlobalMem.has_value())
-                    {
-                        dev.m_deviceProperties->freeGlobalMem = cpu::detail::getFreeGlobalMemSizeBytes();
-                    }
-                }
-                return dev.m_deviceProperties->freeGlobalMem.value();
+                return cpu::detail::getFreeGlobalMemSizeBytes();
             }
         };
 
diff --git a/include/alpaka/dev/DevGenericSycl.hpp b/include/alpaka/dev/DevGenericSycl.hpp
@@ -113,10 +113,21 @@ namespace alpaka
                 return m_context;
             }
 
+            std::shared_mutex& mutex()
+            {
+                return m_mutex;
+            }
+
+            alpaka::DeviceProperties& deviceProperties()
+            {
+                return m_deviceProperties;
+            }
+
         private:
             sycl::device m_device;
             sycl::context m_context;
             std::vector<std::weak_ptr<QueueGenericSyclImpl>> m_queues;
+            alpaka::DeviceProperties m_deviceProperties;
             std::shared_mutex mutable m_mutex;
         };
     } // namespace detail
@@ -132,8 +143,6 @@ namespace alpaka
     public:
         DevGenericSycl(sycl::device device, sycl::context context)
             : m_impl{std::make_shared<detail::DevGenericSyclImpl>(std::move(device), std::move(context))}
-            , m_deviceProperties{std::make_shared<alpaka::DeviceProperties>()}
-            , m_mutex{std::make_shared<std::mutex>()}
         {
         }
 
@@ -153,8 +162,6 @@ namespace alpaka
         }
 
         std::shared_ptr<detail::DevGenericSyclImpl> m_impl;
-        std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;
-        std::shared_ptr<std::mutex> m_mutex;
     };
 
     namespace trait
@@ -166,14 +173,14 @@ namespace alpaka
             static auto getName(DevGenericSycl<TTag> const& dev) -> std::string
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->name.has_value())
+                    std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());
+                    if(!dev.m_impl->deviceProperties().name.has_value())
                     {
                         auto const device = dev.getNativeHandle().first;
-                        dev.m_deviceProperties->name = device.template get_info<sycl::info::device::name>();
+                        dev.m_impl->deviceProperties().name = device.template get_info<sycl::info::device::name>();
                     }
                 }
-                return dev.m_deviceProperties->name.value();
+                return dev.m_impl->deviceProperties().name.value();
             }
         };
 
@@ -184,15 +191,15 @@ namespace alpaka
             static auto getMemBytes(DevGenericSycl<TTag> const& dev) -> std::size_t
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->totalGlobalMem.has_value())
+                    std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());
+                    if(!dev.m_impl->deviceProperties().totalGlobalMem.has_value())
                     {
                         auto const device = dev.getNativeHandle().first;
-                        dev.m_deviceProperties->totalGlobalMem
+                        dev.m_impl->deviceProperties().totalGlobalMem
                             = device.template get_info<sycl::info::device::global_mem_size>();
                     }
                 }
-                return dev.m_deviceProperties->totalGlobalMem.value();
+                return dev.m_impl->deviceProperties().totalGlobalMem.value();
             }
         };
 
@@ -216,8 +223,8 @@ namespace alpaka
             static auto getWarpSizes(DevGenericSycl<TTag> const& dev) -> std::vector<std::size_t>
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->warpSizes.has_value())
+                    std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());
+                    if(!dev.m_impl->deviceProperties().warpSizes.has_value())
                     {
                         auto const device = dev.getNativeHandle().first;
                         std::vector<std::size_t> warp_sizes
@@ -229,10 +236,10 @@ namespace alpaka
                             warp_sizes.erase(find64);
                         // Sort the warp sizes in decreasing order
                         std::sort(warp_sizes.begin(), warp_sizes.end(), std::greater<>{});
-                        dev.m_deviceProperties->warpSizes = std::move(warp_sizes);
+                        dev.m_impl->deviceProperties().warpSizes = std::move(warp_sizes);
                     }
                 }
-                return dev.m_deviceProperties->warpSizes.value();
+                return dev.m_impl->deviceProperties().warpSizes.value();
             }
         };
 
@@ -243,10 +250,10 @@ namespace alpaka
             static auto getPreferredWarpSize(DevGenericSycl<TTag> const& dev) -> std::size_t
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(dev.m_deviceProperties->warpSizes.has_value())
+                    std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());
+                    if(dev.m_impl->deviceProperties().warpSizes.has_value())
                     {
-                        return dev.m_deviceProperties->warpSizes.value().front();
+                        return dev.m_impl->deviceProperties().warpSizes.value().front();
                     }
                 }
                 return GetWarpSizes<DevGenericSycl<TTag>>::getWarpSizes(dev).front();
diff --git a/include/alpaka/dev/DevUniformCudaHipRt.hpp b/include/alpaka/dev/DevUniformCudaHipRt.hpp
@@ -64,10 +64,7 @@ namespace alpaka
         using IDeviceQueue = uniform_cuda_hip::detail::QueueUniformCudaHipRtImpl<TApi>;
 
     protected:
-        DevUniformCudaHipRt()
-            : m_QueueRegistry{std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>()}
-            , m_deviceProperties{std::make_shared<alpaka::DeviceProperties>()}
-            , m_mutex(std::make_shared<std::mutex>())
+        DevUniformCudaHipRt() : m_QueueRegistry{std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>()}
         {
         }
 
@@ -109,16 +106,12 @@ namespace alpaka
         DevUniformCudaHipRt(int iDevice)
             : m_iDevice(iDevice)
             , m_QueueRegistry(std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>())
-            , m_deviceProperties(std::make_shared<alpaka::DeviceProperties>())
-            , m_mutex(std::make_shared<std::mutex>())
         {
         }
 
         int m_iDevice;
 
         std::shared_ptr<alpaka::detail::QueueRegistry<IDeviceQueue>> m_QueueRegistry;
-        std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;
-        std::shared_ptr<std::mutex> m_mutex;
     };
 
     namespace trait
@@ -130,18 +123,18 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getName(DevUniformCudaHipRt<TApi> const& dev) -> std::string
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->name.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());
+                    if(!dev.m_QueueRegistry->deviceProperties().name.has_value())
                     {
                         // There is cuda/hip-DeviceGetAttribute as faster alternative to cuda/hip-GetDeviceProperties
                         // to get a single device property but it has no option to get the name
                         typename TApi::DeviceProp_t devProp;
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::getDeviceProperties(&devProp, dev.getNativeHandle()));
-                        dev.m_deviceProperties->name = std::string(devProp.name);
+                        dev.m_QueueRegistry->deviceProperties().name = std::string(devProp.name);
                     }
                 }
 
-                return dev.m_deviceProperties->name.value();
+                return dev.m_QueueRegistry->deviceProperties().name.value();
             }
         };
 
@@ -152,8 +145,8 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getMemBytes(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->freeGlobalMem.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());
+                    if(!dev.m_QueueRegistry->deviceProperties().totalGlobalMem.has_value())
                     {
                         // Set the current device to wait for.
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::setDevice(dev.getNativeHandle()));
@@ -163,12 +156,11 @@ namespace alpaka
 
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::memGetInfo(&freeInternal, &totalInternal));
 
-                        dev.m_deviceProperties->totalGlobalMem = totalInternal;
-                        dev.m_deviceProperties->freeGlobalMem = freeInternal;
+                        dev.m_QueueRegistry->deviceProperties().totalGlobalMem = totalInternal;
                     }
                 }
 
-                return dev.m_deviceProperties->totalGlobalMem.value();
+                return dev.m_QueueRegistry->deviceProperties().totalGlobalMem.value();
             }
         };
 
@@ -178,24 +170,23 @@ namespace alpaka
         {
             ALPAKA_FN_HOST static auto getFreeMemBytes(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t
             {
+                std::size_t freeInternal(0u);
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->totalGlobalMem.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());
+                    if(!dev.m_QueueRegistry->deviceProperties().totalGlobalMem.has_value())
                     {
                         // Set the current device to wait for.
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::setDevice(dev.getNativeHandle()));
 
-                        std::size_t freeInternal(0u);
                         std::size_t totalInternal(0u);
 
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::memGetInfo(&freeInternal, &totalInternal));
 
-                        dev.m_deviceProperties->totalGlobalMem = totalInternal;
-                        dev.m_deviceProperties->freeGlobalMem = freeInternal;
+                        dev.m_QueueRegistry->deviceProperties().totalGlobalMem = totalInternal;
                     }
                 }
 
-                return dev.m_deviceProperties->freeGlobalMem.value();
+                return freeInternal;
             }
         };
 
@@ -206,14 +197,14 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getWarpSizes(DevUniformCudaHipRt<TApi> const& dev) -> std::vector<std::size_t>
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->warpSizes.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());
+                    if(!dev.m_QueueRegistry->deviceProperties().warpSizes.has_value())
                     {
-                        dev.m_deviceProperties->warpSizes = std::vector<std::size_t>{
+                        dev.m_QueueRegistry->deviceProperties().warpSizes = std::vector<std::size_t>{
                             GetPreferredWarpSize<DevUniformCudaHipRt<TApi>>::getPreferredWarpSize(dev)};
                     }
                 }
-                return dev.m_deviceProperties->warpSizes.value();
+                return dev.m_QueueRegistry->deviceProperties().warpSizes.value();
             }
         };
 
@@ -224,18 +215,18 @@ namespace alpaka
             ALPAKA_FN_HOST static auto getPreferredWarpSize(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t
             {
                 {
-                    std::lock_guard<std::mutex> lock(*dev.m_mutex);
-                    if(!dev.m_deviceProperties->preferredWarpSize.has_value())
+                    std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());
+                    if(!dev.m_QueueRegistry->deviceProperties().preferredWarpSize.has_value())
                     {
                         int warpSize = 0;
 
                         ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(
                             TApi::deviceGetAttribute(&warpSize, TApi::deviceAttributeWarpSize, dev.getNativeHandle()));
-                        dev.m_deviceProperties->preferredWarpSize = static_cast<std::size_t>(warpSize);
+                        dev.m_QueueRegistry->deviceProperties().preferredWarpSize = static_cast<std::size_t>(warpSize);
                     }
                 }
 
-                return dev.m_deviceProperties->preferredWarpSize.value();
+                return dev.m_QueueRegistry->deviceProperties().preferredWarpSize.value();
             }
         };
 
diff --git a/include/alpaka/dev/common/DeviceProperties.hpp b/include/alpaka/dev/common/DeviceProperties.hpp
@@ -13,7 +13,6 @@ namespace alpaka
     {
         std::optional<std::string> name;
         std::optional<std::size_t> totalGlobalMem;
-        std::optional<std::size_t> freeGlobalMem;
         std::optional<std::vector<std::size_t>> warpSizes;
         std::optional<std::size_t> preferredWarpSize;
 
diff --git a/include/alpaka/dev/common/QueueRegistry.hpp b/include/alpaka/dev/common/QueueRegistry.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "alpaka/core/Common.hpp"
+#include "alpaka/dev/common/DeviceProperties.hpp"
 
 #include <deque>
 #include <functional>
@@ -52,8 +53,19 @@ namespace alpaka::detail
             m_queues.push_back(spQueue);
         }
 
+        std::mutex& mutex()
+        {
+            return m_Mutex;
+        }
+
+        alpaka::DeviceProperties& deviceProperties()
+        {
+            return m_deviceProperties;
+        }
+
     private:
         std::mutex mutable m_Mutex;
+        alpaka::DeviceProperties m_deviceProperties;
         std::deque<std::weak_ptr<TQueue>> mutable m_queues;
     };
 } // namespace alpaka::detail

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`	`#pragma once`
`7`	`7`
`8`	`8`	`#include "alpaka/dev/Traits.hpp"`
`9`		`-#include "alpaka/dev/common/DeviceProperties.hpp"`
`10`	`9`	`#include "alpaka/dev/common/QueueRegistry.hpp"`
`11`	`10`	`#include "alpaka/dev/cpu/SysInfo.hpp"`
`12`	`11`	`#include "alpaka/mem/buf/Traits.hpp"`
`@@ -58,10 +57,7 @@ namespace alpaka`
`58`	`57`	`friend struct trait::GetDevByIdx<PlatformCpu>;`
`59`	`58`
`60`	`59`	`protected:`
`61`		`- DevCpu()`
`62`		`- : m_spDevCpuImpl(std::make_shared<cpu::detail::DevCpuImpl>())`
`63`		`- , m_deviceProperties(std::make_shared<alpaka::DeviceProperties>())`
`64`		`- , m_mutex(std::make_shared<std::mutex>())`
	`60`	`+ DevCpu() : m_spDevCpuImpl(std::make_shared<cpu::detail::DevCpuImpl>())`
`65`	`61`	`{`
`66`	`62`	`}`
`67`	`63`
`@@ -101,8 +97,6 @@ namespace alpaka`
`101`	`97`
`102`	`98`	`private:`
`103`	`99`	`std::shared_ptr<cpu::detail::DevCpuImpl> m_spDevCpuImpl;`
`104`		`- std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;`
`105`		`- std::shared_ptr<std::mutex> m_mutex;`
`106`	`100`	`};`
`107`	`101`
`108`	`102`	`namespace trait`
`@@ -114,13 +108,13 @@ namespace alpaka`
`114`	`108`	`ALPAKA_FN_HOST static auto getName(DevCpu const& dev) -> std::string`
`115`	`109`	`{`
`116`	`110`	`{`
`117`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`118`		`- if(!dev.m_deviceProperties->name.has_value())`
	`111`	`+ std::lock_guard<std::mutex> lock(dev.m_spDevCpuImpl->mutex());`
	`112`	`+ if(!dev.m_spDevCpuImpl->deviceProperties().name.has_value())`
`119`	`113`	`{`
`120`		`- dev.m_deviceProperties->name = cpu::detail::getCpuName();`
	`114`	`+ dev.m_spDevCpuImpl->deviceProperties().name = cpu::detail::getCpuName();`
`121`	`115`	`}`
`122`	`116`	`}`
`123`		`- return dev.m_deviceProperties->name.value();`
	`117`	`+ return dev.m_spDevCpuImpl->deviceProperties().name.value();`
`124`	`118`	`}`
`125`	`119`	`};`
`126`	`120`
`@@ -131,30 +125,24 @@ namespace alpaka`
`131`	`125`	`ALPAKA_FN_HOST static auto getMemBytes(DevCpu const& dev) -> std::size_t`
`132`	`126`	`{`
`133`	`127`	`{`
`134`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`135`		`- if(!dev.m_deviceProperties->totalGlobalMem.has_value())`
	`128`	`+ std::lock_guard<std::mutex> lock(dev.m_spDevCpuImpl->mutex());`
	`129`	`+ if(!dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem.has_value())`
`136`	`130`	`{`
`137`		`- dev.m_deviceProperties->totalGlobalMem = cpu::detail::getTotalGlobalMemSizeBytes();`
	`131`	`+ dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem`
	`132`	`+ = cpu::detail::getTotalGlobalMemSizeBytes();`
`138`	`133`	`}`
`139`	`134`	`}`
`140`		`- return dev.m_deviceProperties->totalGlobalMem.value();`
	`135`	`+ return dev.m_spDevCpuImpl->deviceProperties().totalGlobalMem.value();`
`141`	`136`	`}`
`142`	`137`	`};`
`143`	`138`
`144`	`139`	`//! The CPU device free memory get trait specialization.`
`145`	`140`	`template<>`
`146`	`141`	`struct GetFreeMemBytes<DevCpu>`
`147`	`142`	`{`
`148`		`- ALPAKA_FN_HOST static auto getFreeMemBytes(DevCpu const& dev) -> std::size_t`
	`143`	`+ ALPAKA_FN_HOST static auto getFreeMemBytes(DevCpu const& /* dev */) -> std::size_t`
`149`	`144`	`{`
`150`		`- {`
`151`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`152`		`- if(!dev.m_deviceProperties->freeGlobalMem.has_value())`
`153`		`- {`
`154`		`- dev.m_deviceProperties->freeGlobalMem = cpu::detail::getFreeGlobalMemSizeBytes();`
`155`		`- }`
`156`		`- }`
`157`		`- return dev.m_deviceProperties->freeGlobalMem.value();`
	`145`	`+ return cpu::detail::getFreeGlobalMemSizeBytes();`
`158`	`146`	`}`
`159`	`147`	`};`
`160`	`148`
Original file line number	Diff line number	Diff line change
`@@ -113,10 +113,21 @@ namespace alpaka`
`113`	`113`	`return m_context;`
`114`	`114`	`}`
`115`	`115`
	`116`	`+ std::shared_mutex& mutex()`
	`117`	`+ {`
	`118`	`+ return m_mutex;`
	`119`	`+ }`
	`120`	`+`
	`121`	`+ alpaka::DeviceProperties& deviceProperties()`
	`122`	`+ {`
	`123`	`+ return m_deviceProperties;`
	`124`	`+ }`
	`125`	`+`
`116`	`126`	`private:`
`117`	`127`	`sycl::device m_device;`
`118`	`128`	`sycl::context m_context;`
`119`	`129`	`std::vector<std::weak_ptr<QueueGenericSyclImpl>> m_queues;`
	`130`	`+ alpaka::DeviceProperties m_deviceProperties;`
`120`	`131`	`std::shared_mutex mutable m_mutex;`
`121`	`132`	`};`
`122`	`133`	`} // namespace detail`
`@@ -132,8 +143,6 @@ namespace alpaka`
`132`	`143`	`public:`
`133`	`144`	`DevGenericSycl(sycl::device device, sycl::context context)`
`134`	`145`	`: m_impl{std::make_shared<detail::DevGenericSyclImpl>(std::move(device), std::move(context))}`
`135`		`- , m_deviceProperties{std::make_shared<alpaka::DeviceProperties>()}`
`136`		`- , m_mutex{std::make_shared<std::mutex>()}`
`137`	`146`	`{`
`138`	`147`	`}`
`139`	`148`
`@@ -153,8 +162,6 @@ namespace alpaka`
`153`	`162`	`}`
`154`	`163`
`155`	`164`	`std::shared_ptr<detail::DevGenericSyclImpl> m_impl;`
`156`		`- std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;`
`157`		`- std::shared_ptr<std::mutex> m_mutex;`
`158`	`165`	`};`
`159`	`166`
`160`	`167`	`namespace trait`
`@@ -166,14 +173,14 @@ namespace alpaka`
`166`	`173`	`static auto getName(DevGenericSycl<TTag> const& dev) -> std::string`
`167`	`174`	`{`
`168`	`175`	`{`
`169`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`170`		`- if(!dev.m_deviceProperties->name.has_value())`
	`176`	`+ std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());`
	`177`	`+ if(!dev.m_impl->deviceProperties().name.has_value())`
`171`	`178`	`{`
`172`	`179`	`auto const device = dev.getNativeHandle().first;`
`173`		`- dev.m_deviceProperties->name = device.template get_info<sycl::info::device::name>();`
	`180`	`+ dev.m_impl->deviceProperties().name = device.template get_info<sycl::info::device::name>();`
`174`	`181`	`}`
`175`	`182`	`}`
`176`		`- return dev.m_deviceProperties->name.value();`
	`183`	`+ return dev.m_impl->deviceProperties().name.value();`
`177`	`184`	`}`
`178`	`185`	`};`
`179`	`186`
`@@ -184,15 +191,15 @@ namespace alpaka`
`184`	`191`	`static auto getMemBytes(DevGenericSycl<TTag> const& dev) -> std::size_t`
`185`	`192`	`{`
`186`	`193`	`{`
`187`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`188`		`- if(!dev.m_deviceProperties->totalGlobalMem.has_value())`
	`194`	`+ std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());`
	`195`	`+ if(!dev.m_impl->deviceProperties().totalGlobalMem.has_value())`
`189`	`196`	`{`
`190`	`197`	`auto const device = dev.getNativeHandle().first;`
`191`		`- dev.m_deviceProperties->totalGlobalMem`
	`198`	`+ dev.m_impl->deviceProperties().totalGlobalMem`
`192`	`199`	`= device.template get_info<sycl::info::device::global_mem_size>();`
`193`	`200`	`}`
`194`	`201`	`}`
`195`		`- return dev.m_deviceProperties->totalGlobalMem.value();`
	`202`	`+ return dev.m_impl->deviceProperties().totalGlobalMem.value();`
`196`	`203`	`}`
`197`	`204`	`};`
`198`	`205`
`@@ -216,8 +223,8 @@ namespace alpaka`
`216`	`223`	`static auto getWarpSizes(DevGenericSycl<TTag> const& dev) -> std::vector<std::size_t>`
`217`	`224`	`{`
`218`	`225`	`{`
`219`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`220`		`- if(!dev.m_deviceProperties->warpSizes.has_value())`
	`226`	`+ std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());`
	`227`	`+ if(!dev.m_impl->deviceProperties().warpSizes.has_value())`
`221`	`228`	`{`
`222`	`229`	`auto const device = dev.getNativeHandle().first;`
`223`	`230`	`std::vector<std::size_t> warp_sizes`
`@@ -229,10 +236,10 @@ namespace alpaka`
`229`	`236`	`warp_sizes.erase(find64);`
`230`	`237`	`// Sort the warp sizes in decreasing order`
`231`	`238`	`std::sort(warp_sizes.begin(), warp_sizes.end(), std::greater<>{});`
`232`		`- dev.m_deviceProperties->warpSizes = std::move(warp_sizes);`
	`239`	`+ dev.m_impl->deviceProperties().warpSizes = std::move(warp_sizes);`
`233`	`240`	`}`
`234`	`241`	`}`
`235`		`- return dev.m_deviceProperties->warpSizes.value();`
	`242`	`+ return dev.m_impl->deviceProperties().warpSizes.value();`
`236`	`243`	`}`
`237`	`244`	`};`
`238`	`245`
`@@ -243,10 +250,10 @@ namespace alpaka`
`243`	`250`	`static auto getPreferredWarpSize(DevGenericSycl<TTag> const& dev) -> std::size_t`
`244`	`251`	`{`
`245`	`252`	`{`
`246`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`247`		`- if(dev.m_deviceProperties->warpSizes.has_value())`
	`253`	`+ std::lock_guard<std::shared_mutex> lock(dev.m_impl->mutex());`
	`254`	`+ if(dev.m_impl->deviceProperties().warpSizes.has_value())`
`248`	`255`	`{`
`249`		`- return dev.m_deviceProperties->warpSizes.value().front();`
	`256`	`+ return dev.m_impl->deviceProperties().warpSizes.value().front();`
`250`	`257`	`}`
`251`	`258`	`}`
`252`	`259`	`return GetWarpSizes<DevGenericSycl<TTag>>::getWarpSizes(dev).front();`
Original file line number	Diff line number	Diff line change
`@@ -64,10 +64,7 @@ namespace alpaka`
`64`	`64`	`using IDeviceQueue = uniform_cuda_hip::detail::QueueUniformCudaHipRtImpl<TApi>;`
`65`	`65`
`66`	`66`	`protected:`
`67`		`- DevUniformCudaHipRt()`
`68`		`- : m_QueueRegistry{std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>()}`
`69`		`- , m_deviceProperties{std::make_shared<alpaka::DeviceProperties>()}`
`70`		`- , m_mutex(std::make_shared<std::mutex>())`
	`67`	`+ DevUniformCudaHipRt() : m_QueueRegistry{std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>()}`
`71`	`68`	`{`
`72`	`69`	`}`
`73`	`70`
`@@ -109,16 +106,12 @@ namespace alpaka`
`109`	`106`	`DevUniformCudaHipRt(int iDevice)`
`110`	`107`	`: m_iDevice(iDevice)`
`111`	`108`	`, m_QueueRegistry(std::make_shared<alpaka::detail::QueueRegistry<IDeviceQueue>>())`
`112`		`- , m_deviceProperties(std::make_shared<alpaka::DeviceProperties>())`
`113`		`- , m_mutex(std::make_shared<std::mutex>())`
`114`	`109`	`{`
`115`	`110`	`}`
`116`	`111`
`117`	`112`	`int m_iDevice;`
`118`	`113`
`119`	`114`	`std::shared_ptr<alpaka::detail::QueueRegistry<IDeviceQueue>> m_QueueRegistry;`
`120`		`- std::shared_ptr<alpaka::DeviceProperties> m_deviceProperties;`
`121`		`- std::shared_ptr<std::mutex> m_mutex;`
`122`	`115`	`};`
`123`	`116`
`124`	`117`	`namespace trait`
`@@ -130,18 +123,18 @@ namespace alpaka`
`130`	`123`	`ALPAKA_FN_HOST static auto getName(DevUniformCudaHipRt<TApi> const& dev) -> std::string`
`131`	`124`	`{`
`132`	`125`	`{`
`133`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`134`		`- if(!dev.m_deviceProperties->name.has_value())`
	`126`	`+ std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());`
	`127`	`+ if(!dev.m_QueueRegistry->deviceProperties().name.has_value())`
`135`	`128`	`{`
`136`	`129`	`// There is cuda/hip-DeviceGetAttribute as faster alternative to cuda/hip-GetDeviceProperties`
`137`	`130`	`// to get a single device property but it has no option to get the name`
`138`	`131`	`typename TApi::DeviceProp_t devProp;`
`139`	`132`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::getDeviceProperties(&devProp, dev.getNativeHandle()));`
`140`		`- dev.m_deviceProperties->name = std::string(devProp.name);`
	`133`	`+ dev.m_QueueRegistry->deviceProperties().name = std::string(devProp.name);`
`141`	`134`	`}`
`142`	`135`	`}`
`143`	`136`
`144`		`- return dev.m_deviceProperties->name.value();`
	`137`	`+ return dev.m_QueueRegistry->deviceProperties().name.value();`
`145`	`138`	`}`
`146`	`139`	`};`
`147`	`140`
`@@ -152,8 +145,8 @@ namespace alpaka`
`152`	`145`	`ALPAKA_FN_HOST static auto getMemBytes(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t`
`153`	`146`	`{`
`154`	`147`	`{`
`155`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`156`		`- if(!dev.m_deviceProperties->freeGlobalMem.has_value())`
	`148`	`+ std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());`
	`149`	`+ if(!dev.m_QueueRegistry->deviceProperties().totalGlobalMem.has_value())`
`157`	`150`	`{`
`158`	`151`	`// Set the current device to wait for.`
`159`	`152`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::setDevice(dev.getNativeHandle()));`
`@@ -163,12 +156,11 @@ namespace alpaka`
`163`	`156`
`164`	`157`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::memGetInfo(&freeInternal, &totalInternal));`
`165`	`158`
`166`		`- dev.m_deviceProperties->totalGlobalMem = totalInternal;`
`167`		`- dev.m_deviceProperties->freeGlobalMem = freeInternal;`
	`159`	`+ dev.m_QueueRegistry->deviceProperties().totalGlobalMem = totalInternal;`
`168`	`160`	`}`
`169`	`161`	`}`
`170`	`162`
`171`		`- return dev.m_deviceProperties->totalGlobalMem.value();`
	`163`	`+ return dev.m_QueueRegistry->deviceProperties().totalGlobalMem.value();`
`172`	`164`	`}`
`173`	`165`	`};`
`174`	`166`
`@@ -178,24 +170,23 @@ namespace alpaka`
`178`	`170`	`{`
`179`	`171`	`ALPAKA_FN_HOST static auto getFreeMemBytes(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t`
`180`	`172`	`{`
	`173`	`+ std::size_t freeInternal(0u);`
`181`	`174`	`{`
`182`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`183`		`- if(!dev.m_deviceProperties->totalGlobalMem.has_value())`
	`175`	`+ std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());`
	`176`	`+ if(!dev.m_QueueRegistry->deviceProperties().totalGlobalMem.has_value())`
`184`	`177`	`{`
`185`	`178`	`// Set the current device to wait for.`
`186`	`179`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::setDevice(dev.getNativeHandle()));`
`187`	`180`
`188`		`- std::size_t freeInternal(0u);`
`189`	`181`	`std::size_t totalInternal(0u);`
`190`	`182`
`191`	`183`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::memGetInfo(&freeInternal, &totalInternal));`
`192`	`184`
`193`		`- dev.m_deviceProperties->totalGlobalMem = totalInternal;`
`194`		`- dev.m_deviceProperties->freeGlobalMem = freeInternal;`
	`185`	`+ dev.m_QueueRegistry->deviceProperties().totalGlobalMem = totalInternal;`
`195`	`186`	`}`
`196`	`187`	`}`
`197`	`188`
`198`		`- return dev.m_deviceProperties->freeGlobalMem.value();`
	`189`	`+ return freeInternal;`
`199`	`190`	`}`
`200`	`191`	`};`
`201`	`192`
`@@ -206,14 +197,14 @@ namespace alpaka`
`206`	`197`	`ALPAKA_FN_HOST static auto getWarpSizes(DevUniformCudaHipRt<TApi> const& dev) -> std::vector<std::size_t>`
`207`	`198`	`{`
`208`	`199`	`{`
`209`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`210`		`- if(!dev.m_deviceProperties->warpSizes.has_value())`
	`200`	`+ std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());`
	`201`	`+ if(!dev.m_QueueRegistry->deviceProperties().warpSizes.has_value())`
`211`	`202`	`{`
`212`		`- dev.m_deviceProperties->warpSizes = std::vector<std::size_t>{`
	`203`	`+ dev.m_QueueRegistry->deviceProperties().warpSizes = std::vector<std::size_t>{`
`213`	`204`	`GetPreferredWarpSize<DevUniformCudaHipRt<TApi>>::getPreferredWarpSize(dev)};`
`214`	`205`	`}`
`215`	`206`	`}`
`216`		`- return dev.m_deviceProperties->warpSizes.value();`
	`207`	`+ return dev.m_QueueRegistry->deviceProperties().warpSizes.value();`
`217`	`208`	`}`
`218`	`209`	`};`
`219`	`210`
`@@ -224,18 +215,18 @@ namespace alpaka`
`224`	`215`	`ALPAKA_FN_HOST static auto getPreferredWarpSize(DevUniformCudaHipRt<TApi> const& dev) -> std::size_t`
`225`	`216`	`{`
`226`	`217`	`{`
`227`		`- std::lock_guard<std::mutex> lock(*dev.m_mutex);`
`228`		`- if(!dev.m_deviceProperties->preferredWarpSize.has_value())`
	`218`	`+ std::lock_guard<std::mutex> lock(dev.m_QueueRegistry->mutex());`
	`219`	`+ if(!dev.m_QueueRegistry->deviceProperties().preferredWarpSize.has_value())`
`229`	`220`	`{`
`230`	`221`	`int warpSize = 0;`
`231`	`222`
`232`	`223`	`ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(`
`233`	`224`	`TApi::deviceGetAttribute(&warpSize, TApi::deviceAttributeWarpSize, dev.getNativeHandle()));`
`234`		`- dev.m_deviceProperties->preferredWarpSize = static_cast<std::size_t>(warpSize);`
	`225`	`+ dev.m_QueueRegistry->deviceProperties().preferredWarpSize = static_cast<std::size_t>(warpSize);`
`235`	`226`	`}`
`236`	`227`	`}`
`237`	`228`
`238`		`- return dev.m_deviceProperties->preferredWarpSize.value();`
	`229`	`+ return dev.m_QueueRegistry->deviceProperties().preferredWarpSize.value();`
`239`	`230`	`}`
`240`	`231`	`};`
`241`	`232`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,6 @@ namespace alpaka`
`13`	`13`	`{`
`14`	`14`	`std::optional<std::string> name;`
`15`	`15`	`std::optional<std::size_t> totalGlobalMem;`
`16`		`- std::optional<std::size_t> freeGlobalMem;`
`17`	`16`	`std::optional<std::vector<std::size_t>> warpSizes;`
`18`	`17`	`std::optional<std::size_t> preferredWarpSize;`
`19`	`18`