examples,src: Handle and fix more recent clang-tidy warnings

stotko · stotko · commit 53b81d0bde0a · 2025-10-14T11:02:46.000+02:00
diff --git a/.clang-tidy b/.clang-tidy
@@ -23,6 +23,7 @@ hicpp-*,\
 misc-*,\
 -misc-const-correctness,\
 -misc-include-cleaner,\
+-misc-use-internal-linkage,\
 modernize-*,\
 -modernize-avoid-c-arrays,\
 -modernize-use-auto,\
diff --git a/examples/createAndDestroyDeviceObject.cpp b/examples/createAndDestroyDeviceObject.cpp
@@ -69,7 +69,7 @@ class Image
     STDGPU_HOST_DEVICE std::uint8_t&
     operator()(const stdgpu::index_t x, const stdgpu::index_t y)
     {
-        return _values[y * _width + x];
+        return _values[(y * _width) + x];
     }
 
     STDGPU_HOST_DEVICE stdgpu::index_t
diff --git a/src/stdgpu/impl/algorithm_detail.h b/src/stdgpu/impl/algorithm_detail.h
@@ -29,14 +29,14 @@ template <class T>
 constexpr STDGPU_HOST_DEVICE const T&
 min(const T& a, const T& b)
 {
-    return (b < a) ? b : a;
+    return (b < a) ? b : a; // NOLINT(bugprone-return-const-ref-from-parameter)
 }
 
 template <class T>
 constexpr STDGPU_HOST_DEVICE const T&
 max(const T& a, const T& b)
 {
-    return (a < b) ? b : a;
+    return (a < b) ? b : a; // NOLINT(bugprone-return-const-ref-from-parameter)
 }
 
 template <class T>
@@ -45,7 +45,8 @@ clamp(const T& v, const T& lower, const T& upper)
 {
     STDGPU_EXPECTS(!(upper < lower));
 
-    return v < lower ? lower : upper < v ? upper : v; // NOLINT(readability-avoid-nested-conditional-operator)
+    // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter,readability-avoid-nested-conditional-operator)
+    return v < lower ? lower : upper < v ? upper : v;
 }
 
 template <typename IndexType,
@@ -58,7 +59,7 @@ for_each_index(ExecutionPolicy&& policy, IndexType size, UnaryFunction f)
     thrust::for_each(std::forward<ExecutionPolicy>(policy),
                      thrust::counting_iterator<IndexType>(0),
                      thrust::counting_iterator<IndexType>(size),
-                     f);
+                     std::move(f));
 }
 
 namespace detail
diff --git a/src/stdgpu/impl/bitset_detail.cuh b/src/stdgpu/impl/bitset_detail.cuh
@@ -17,6 +17,7 @@
 #define STDGPU_BITSET_DETAIL_H
 
 #include <limits>
+#include <type_traits>
 
 #include <stdgpu/algorithm.h>
 #include <stdgpu/atomic.cuh>
@@ -119,7 +120,7 @@ div_up(const index_t a, const index_t b) noexcept
     STDGPU_EXPECTS(a >= 0);
     STDGPU_EXPECTS(b > 0);
 
-    index_t result = (a % b != 0) ? (a / b + 1) : (a / b);
+    index_t result = (a % b != 0) ? ((a / b) + 1) : (a / b);
 
     STDGPU_ENSURES(result * b >= a);
 
@@ -146,7 +147,7 @@ private:
     STDGPU_HOST_DEVICE Block
     block_mask(const index_t i) const
     {
-        index_t remaining_bits = _size - i * _bits_per_block;
+        index_t remaining_bits = _size - (i * _bits_per_block);
         return (remaining_bits >= _bits_per_block)
                        ? ~static_cast<Block>(0)
                        : (static_cast<Block>(1) << static_cast<Block>(remaining_bits)) - static_cast<Block>(1);
@@ -256,7 +257,7 @@ template <typename ExecutionPolicy,
 inline void
 bitset<Block, Allocator>::set(ExecutionPolicy&& policy)
 {
-    fill(std::forward<ExecutionPolicy>(policy), device_begin(_bit_blocks), device_end(_bit_blocks), ~block_type(0));
+    fill(std::decay_t<ExecutionPolicy>{ policy }, device_begin(_bit_blocks), device_end(_bit_blocks), ~block_type(0));
 
     STDGPU_ENSURES(count(std::forward<ExecutionPolicy>(policy)) == size());
 }
@@ -284,7 +285,7 @@ template <typename ExecutionPolicy,
 inline void
 bitset<Block, Allocator>::reset(ExecutionPolicy&& policy)
 {
-    fill(std::forward<ExecutionPolicy>(policy), device_begin(_bit_blocks), device_end(_bit_blocks), block_type(0));
+    fill(std::decay_t<ExecutionPolicy>{ policy }, device_begin(_bit_blocks), device_end(_bit_blocks), block_type(0));
 
     STDGPU_ENSURES(count(std::forward<ExecutionPolicy>(policy)) == 0);
 }
diff --git a/src/stdgpu/impl/deque_detail.cuh b/src/stdgpu/impl/deque_detail.cuh
@@ -16,6 +16,8 @@
 #ifndef STDGPU_DEQUE_DETAIL_H
 #define STDGPU_DEQUE_DETAIL_H
 
+#include <type_traits>
+
 #include <stdgpu/contract.h>
 #include <stdgpu/iterator.h>
 #include <stdgpu/memory.h>
@@ -42,19 +44,21 @@ deque<T, Allocator>::createDeviceObject(ExecutionPolicy&& policy, const index_t&
 
     deque<T, Allocator> result(
             mutex_array<mutex_default_type, mutex_array_allocator_type>::createDeviceObject(
-                    std::forward<ExecutionPolicy>(policy),
+                    std::decay_t<ExecutionPolicy>{ policy },
                     capacity,
                     mutex_array_allocator_type(allocator)),
             bitset<bitset_default_type, bitset_allocator_type>::createDeviceObject(
-                    std::forward<ExecutionPolicy>(policy),
+                    std::decay_t<ExecutionPolicy>{ policy },
                     capacity,
                     bitset_allocator_type(allocator)),
-            atomic<int, atomic_int_allocator_type>::createDeviceObject(std::forward<ExecutionPolicy>(policy),
+            atomic<int, atomic_int_allocator_type>::createDeviceObject(std::decay_t<ExecutionPolicy>{ policy },
                                                                        atomic_int_allocator_type(allocator)),
-            atomic<unsigned int, atomic_uint_allocator_type>::createDeviceObject(std::forward<ExecutionPolicy>(policy),
-                                                                                 atomic_uint_allocator_type(allocator)),
-            atomic<unsigned int, atomic_uint_allocator_type>::createDeviceObject(std::forward<ExecutionPolicy>(policy),
-                                                                                 atomic_uint_allocator_type(allocator)),
+            atomic<unsigned int, atomic_uint_allocator_type>::createDeviceObject(
+                    std::decay_t<ExecutionPolicy>{ policy },
+                    atomic_uint_allocator_type(allocator)),
+            atomic<unsigned int, atomic_uint_allocator_type>::createDeviceObject(
+                    std::decay_t<ExecutionPolicy>{ policy },
+                    atomic_uint_allocator_type(allocator)),
             allocator);
     result._data = allocator_traits<allocator_type>::allocate(result._allocator, capacity);
     result._range_indices = allocator_traits<index_allocator_type>::allocate(result._index_allocator, capacity);
@@ -77,7 +81,7 @@ deque<T, Allocator>::destroyDeviceObject(ExecutionPolicy&& policy, deque<T, Allo
 {
     if (!detail::is_destroy_optimizable<value_type>())
     {
-        device_object.clear(std::forward<ExecutionPolicy>(policy));
+        device_object.clear(std::decay_t<ExecutionPolicy>{ policy });
     }
 
     allocator_traits<allocator_type>::deallocate(device_object._allocator,
@@ -89,13 +93,13 @@ deque<T, Allocator>::destroyDeviceObject(ExecutionPolicy&& policy, deque<T, Allo
     device_object._data = nullptr;
     device_object._range_indices = nullptr;
     mutex_array<mutex_default_type, mutex_array_allocator_type>::destroyDeviceObject(
-            std::forward<ExecutionPolicy>(policy),
+            std::decay_t<ExecutionPolicy>{ policy },
             device_object._locks);
-    bitset<bitset_default_type, bitset_allocator_type>::destroyDeviceObject(std::forward<ExecutionPolicy>(policy),
+    bitset<bitset_default_type, bitset_allocator_type>::destroyDeviceObject(std::decay_t<ExecutionPolicy>{ policy },
                                                                             device_object._occupied);
-    atomic<int, atomic_int_allocator_type>::destroyDeviceObject(std::forward<ExecutionPolicy>(policy),
+    atomic<int, atomic_int_allocator_type>::destroyDeviceObject(std::decay_t<ExecutionPolicy>{ policy },
                                                                 device_object._size);
-    atomic<unsigned int, atomic_uint_allocator_type>::destroyDeviceObject(std::forward<ExecutionPolicy>(policy),
+    atomic<unsigned int, atomic_uint_allocator_type>::destroyDeviceObject(std::decay_t<ExecutionPolicy>{ policy },
                                                                           device_object._begin);
     atomic<unsigned int, atomic_uint_allocator_type>::destroyDeviceObject(std::forward<ExecutionPolicy>(policy),
                                                                           device_object._end);
@@ -550,48 +554,50 @@ template <typename ExecutionPolicy,
 inline void
 deque<T, Allocator>::clear(ExecutionPolicy&& policy)
 {
-    if (empty(std::forward<ExecutionPolicy>(policy)))
+    if (empty(std::decay_t<ExecutionPolicy>{ policy }))
     {
         return;
     }
 
     if (!detail::is_destroy_optimizable<value_type>())
     {
-        const index_t begin = static_cast<index_t>(_begin.load(std::forward<ExecutionPolicy>(policy)));
-        const index_t end = static_cast<index_t>(_end.load(std::forward<ExecutionPolicy>(policy)));
+        const index_t begin = static_cast<index_t>(_begin.load(std::decay_t<ExecutionPolicy>{ policy }));
+        const index_t end = static_cast<index_t>(_end.load(std::decay_t<ExecutionPolicy>{ policy }));
 
         // Full, i.e. one large block and begin == end
-        if (full(std::forward<ExecutionPolicy>(policy)))
+        if (full(std::decay_t<ExecutionPolicy>{ policy }))
         {
-            detail::unoptimized_destroy(std::forward<ExecutionPolicy>(policy), device_begin(_data), device_end(_data));
+            detail::unoptimized_destroy(std::decay_t<ExecutionPolicy>{ policy },
+                                        device_begin(_data),
+                                        device_end(_data));
         }
         // One large block
         else if (begin <= end)
         {
-            detail::unoptimized_destroy(std::forward<ExecutionPolicy>(policy),
+            detail::unoptimized_destroy(std::decay_t<ExecutionPolicy>{ policy },
                                         make_device(_data + begin),
                                         make_device(_data + end));
         }
         // Two disconnected blocks
         else
         {
-            detail::unoptimized_destroy(std::forward<ExecutionPolicy>(policy),
+            detail::unoptimized_destroy(std::decay_t<ExecutionPolicy>{ policy },
                                         device_begin(_data),
                                         make_device(_data + end));
-            detail::unoptimized_destroy(std::forward<ExecutionPolicy>(policy),
+            detail::unoptimized_destroy(std::decay_t<ExecutionPolicy>{ policy },
                                         make_device(_data + begin),
                                         device_end(_data));
         }
     }
 
-    _occupied.reset(std::forward<ExecutionPolicy>(policy));
+    _occupied.reset(std::decay_t<ExecutionPolicy>{ policy });
 
-    _size.store(std::forward<ExecutionPolicy>(policy), 0);
+    _size.store(std::decay_t<ExecutionPolicy>{ policy }, 0);
 
-    _begin.store(std::forward<ExecutionPolicy>(policy), 0);
-    _end.store(std::forward<ExecutionPolicy>(policy), 0);
+    _begin.store(std::decay_t<ExecutionPolicy>{ policy }, 0);
+    _end.store(std::decay_t<ExecutionPolicy>{ policy }, 0);
 
-    STDGPU_ENSURES(empty(std::forward<ExecutionPolicy>(policy)));
+    STDGPU_ENSURES(empty(std::decay_t<ExecutionPolicy>{ policy }));
     STDGPU_ENSURES(valid(std::forward<ExecutionPolicy>(policy)));
 }
 
@@ -614,9 +620,9 @@ deque<T, Allocator>::valid(ExecutionPolicy&& policy) const
         return true;
     }
 
-    return (size_valid(std::forward<ExecutionPolicy>(policy)) &&
-            occupied_count_valid(std::forward<ExecutionPolicy>(policy)) &&
-            _locks.valid(std::forward<ExecutionPolicy>(policy)));
+    return (size_valid(std::decay_t<ExecutionPolicy>{ policy }) &&
+            occupied_count_valid(std::decay_t<ExecutionPolicy>{ policy }) &&
+            _locks.valid(std::decay_t<ExecutionPolicy>{ policy }));
 }
 
 template <typename T, typename Allocator>
@@ -632,30 +638,30 @@ template <typename ExecutionPolicy,
 stdgpu::device_indexed_range<T>
 deque<T, Allocator>::device_range(ExecutionPolicy&& policy)
 {
-    const index_t begin = static_cast<index_t>(_begin.load(std::forward<ExecutionPolicy>(policy)));
-    const index_t end = static_cast<index_t>(_end.load(std::forward<ExecutionPolicy>(policy)));
+    const index_t begin = static_cast<index_t>(_begin.load(std::decay_t<ExecutionPolicy>{ policy }));
+    const index_t end = static_cast<index_t>(_end.load(std::decay_t<ExecutionPolicy>{ policy }));
 
     // Full, i.e. one large block and begin == end
-    if (full(std::forward<ExecutionPolicy>(policy)))
+    if (full(std::decay_t<ExecutionPolicy>{ policy }))
     {
-        iota(std::forward<ExecutionPolicy>(policy), device_begin(_range_indices), device_end(_range_indices), 0);
+        iota(std::decay_t<ExecutionPolicy>{ policy }, device_begin(_range_indices), device_end(_range_indices), 0);
     }
     // One large block, including empty block
     else if (begin <= end)
     {
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices),
              device_begin(_range_indices) + (end - begin),
              begin);
     }
     // Two disconnected blocks
     else
     {
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices),
              device_begin(_range_indices) + end,
              0);
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices) + end,
              device_begin(_range_indices) + (end + capacity() - begin),
              begin);
@@ -679,30 +685,30 @@ template <typename ExecutionPolicy,
 stdgpu::device_indexed_range<const T>
 deque<T, Allocator>::device_range(ExecutionPolicy&& policy) const
 {
-    const index_t begin = static_cast<index_t>(_begin.load(std::forward<ExecutionPolicy>(policy)));
-    const index_t end = static_cast<index_t>(_end.load(std::forward<ExecutionPolicy>(policy)));
+    const index_t begin = static_cast<index_t>(_begin.load(std::decay_t<ExecutionPolicy>{ policy }));
+    const index_t end = static_cast<index_t>(_end.load(std::decay_t<ExecutionPolicy>{ policy }));
 
     // Full, i.e. one large block and begin == end
-    if (full(std::forward<ExecutionPolicy>(policy)))
+    if (full(std::decay_t<ExecutionPolicy>{ policy }))
     {
-        iota(std::forward<ExecutionPolicy>(policy), device_begin(_range_indices), device_end(_range_indices), 0);
+        iota(std::decay_t<ExecutionPolicy>{ policy }, device_begin(_range_indices), device_end(_range_indices), 0);
     }
     // One large block, including empty block
     else if (begin <= end)
     {
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices),
              device_begin(_range_indices) + (end - begin),
              begin);
     }
     // Two disconnected blocks
     else
     {
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices),
              device_begin(_range_indices) + end,
              0);
-        iota(std::forward<ExecutionPolicy>(policy),
+        iota(std::decay_t<ExecutionPolicy>{ policy },
              device_begin(_range_indices) + end,
              device_begin(_range_indices) + (end + capacity() - begin),
              begin);
@@ -726,7 +732,7 @@ template <typename ExecutionPolicy,
 bool
 deque<T, Allocator>::occupied_count_valid(ExecutionPolicy&& policy) const
 {
-    index_t size_count = size(std::forward<ExecutionPolicy>(policy));
+    index_t size_count = size(std::decay_t<ExecutionPolicy>{ policy });
     index_t size_sum = _occupied.count(std::forward<ExecutionPolicy>(policy));
 
     return (size_count == size_sum);
diff --git a/src/stdgpu/impl/memory_detail.h b/src/stdgpu/impl/memory_detail.h
@@ -174,7 +174,7 @@ unoptimized_destroy(ExecutionPolicy&& policy, Iterator first, Iterator last)
 
 template <typename T>
 T*
-createDeviceArray(const stdgpu::index64_t count, const T default_value)
+createDeviceArray(const stdgpu::index64_t count, const T default_value) // NOLINT(performance-unnecessary-value-param)
 {
     T* device_array = nullptr;
 
@@ -441,8 +441,8 @@ template <typename ExecutionPolicy,
           typename... Args,
           STDGPU_DETAIL_OVERLOAD_DEFINITION_IF(is_execution_policy_v<remove_cvref_t<ExecutionPolicy>>)>
 device_unique_object<T>::device_unique_object(ExecutionPolicy&& policy, Args&&... args)
-  : _object(new T(T::createDeviceObject(std::forward<ExecutionPolicy>(policy), std::forward<Args>(args)...)),
-            [_policy = std::forward<ExecutionPolicy>(policy)](T* ptr)
+  : _object(new T(T::createDeviceObject(std::decay_t<ExecutionPolicy>{ policy }, std::forward<Args>(args)...)),
+            [_policy = std::decay_t<ExecutionPolicy>{ policy }](T* ptr)
             {
                 T::destroyDeviceObject(_policy, *ptr);
                 delete ptr;
diff --git a/src/stdgpu/impl/unordered_base_detail.cuh b/src/stdgpu/impl/unordered_base_detail.cuh
diff --git a/src/stdgpu/impl/vector_detail.cuh b/src/stdgpu/impl/vector_detail.cuh

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ class Image`
`69`	`69`	`STDGPU_HOST_DEVICE std::uint8_t&`
`70`	`70`	`operator()(const stdgpu::index_t x, const stdgpu::index_t y)`
`71`	`71`	`{`
`72`		`- return _values[y * _width + x];`
	`72`	`+ return _values[(y * _width) + x];`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`STDGPU_HOST_DEVICE stdgpu::index_t`
Original file line number	Diff line number	Diff line change
`@@ -29,14 +29,14 @@ template <class T>`
`29`	`29`	`constexpr STDGPU_HOST_DEVICE const T&`
`30`	`30`	`min(const T& a, const T& b)`
`31`	`31`	`{`
`32`		`- return (b < a) ? b : a;`
	`32`	`+ return (b < a) ? b : a; // NOLINT(bugprone-return-const-ref-from-parameter)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`template <class T>`
`36`	`36`	`constexpr STDGPU_HOST_DEVICE const T&`
`37`	`37`	`max(const T& a, const T& b)`
`38`	`38`	`{`
`39`		`- return (a < b) ? b : a;`
	`39`	`+ return (a < b) ? b : a; // NOLINT(bugprone-return-const-ref-from-parameter)`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`template <class T>`
`@@ -45,7 +45,8 @@ clamp(const T& v, const T& lower, const T& upper)`
`45`	`45`	`{`
`46`	`46`	`STDGPU_EXPECTS(!(upper < lower));`
`47`	`47`
`48`		`- return v < lower ? lower : upper < v ? upper : v; // NOLINT(readability-avoid-nested-conditional-operator)`
	`48`	`+ // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter,readability-avoid-nested-conditional-operator)`
	`49`	`+ return v < lower ? lower : upper < v ? upper : v;`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`template <typename IndexType,`
`@@ -58,7 +59,7 @@ for_each_index(ExecutionPolicy&& policy, IndexType size, UnaryFunction f)`
`58`	`59`	`thrust::for_each(std::forward<ExecutionPolicy>(policy),`
`59`	`60`	`thrust::counting_iterator<IndexType>(0),`
`60`	`61`	`thrust::counting_iterator<IndexType>(size),`
`61`		`- f);`
	`62`	`+ std::move(f));`
`62`	`63`	`}`
`63`	`64`
`64`	`65`	`namespace detail`