Use a distinct forceinline macro not to collide with GR

Signed-off-by: Ivan Čukić <[email protected]>

Author: ivan-cukic

src/core/include/opencmw.hpp

@@ -17,14 +17,16 @@
 #include <print>
 #include <refl.hpp>
 
+#include <opencmw.hpp>
+
 #include <Formatter.hpp>
 #include <units/concepts.h>
 #include <units/quantity.h>
 #include <units/quantity_io.h>
 
-#define FWD(x) std::forward<decltype(x)>(x)               // short-hand notation
-#define forceinline inline __attribute__((always_inline)) // use this for hot-spots only <-> may bloat code size, not fit into cache and consequently slow down execution
-#define neverinline __attribute__((noinline))             // primarily used to avoid inlining (rare) exception handling code
+#define FWD(x) std::forward<decltype(x)>(x)                       // short-hand notation
+#define OPENCMW_FORCEINLINE inline __attribute__((always_inline)) // use this for hot-spots only <-> may bloat code size, not fit into cache and consequently slow down execution
+#define neverinline __attribute__((noinline))                     // primarily used to avoid inlining (rare) exception handling code
 
 #define ENABLE_REFLECTION_FOR(TypeName, ...) \
     REFL_TYPE(TypeName __VA_OPT__(, )) \

src/disruptor/include/disruptor/ClaimStrategy.hpp

@@ -1,6 +1,8 @@
 #ifndef OPENCMW_CPP_CLAIMSTRATEGY_HPP
 #define OPENCMW_CPP_CLAIMSTRATEGY_HPP
 
+#include <opencmw.hpp>
+
 #include <SpinWait.hpp>
 
 #include <disruptor/Sequence.hpp>
@@ -32,10 +34,10 @@ class alignas(kCacheLine) SingleThreadedStrategy {
 
 public:
     SingleThreadedStrategy(Sequence &cursor, WAIT_STRATEGY &waitStrategy)
-        : _cursor(cursor), _waitStrategy(waitStrategy){};
+        : _cursor(cursor), _waitStrategy(waitStrategy) {};
     SingleThreadedStrategy(const SingleThreadedStrategy &)  = delete;
     SingleThreadedStrategy(const SingleThreadedStrategy &&) = delete;
-    void operator=(const SingleThreadedStrategy &) = delete;
+    void operator=(const SingleThreadedStrategy &)          = delete;
 
     bool hasAvailableCapacity(const std::vector<std::shared_ptr<Sequence>> &dependents, const int requiredCapacity, const std::int64_t /*cursorValue*/) const noexcept {
         if (const std::int64_t wrapPoint = (_nextValue + requiredCapacity) - static_cast<std::int64_t>(SIZE); wrapPoint > _cachedValue || _cachedValue > _nextValue) {
@@ -99,8 +101,8 @@ class alignas(kCacheLine) SingleThreadedStrategy {
         }
     }
 
-    [[nodiscard]] forceinline bool isAvailable(std::int64_t sequence) const noexcept { return sequence <= _cursor.value(); }
-    [[nodiscard]] std::int64_t     getHighestPublishedSequence(std::int64_t /*nextSequence*/, std::int64_t availableSequence) const noexcept { return availableSequence; }
+    [[nodiscard]] OPENCMW_FORCEINLINE bool isAvailable(std::int64_t sequence) const noexcept { return sequence <= _cursor.value(); }
+    [[nodiscard]] std::int64_t             getHighestPublishedSequence(std::int64_t /*nextSequence*/, std::int64_t availableSequence) const noexcept { return availableSequence; }
 };
 static_assert(ClaimStrategy<SingleThreadedStrategy<1024, NoWaitStrategy>>);
 
@@ -128,8 +130,8 @@ class MultiThreadedStrategy {
         }
         setAvailableBufferValue(0, -1);
     }
-    MultiThreadedStrategy(const MultiThreadedStrategy &)  = delete;
-    MultiThreadedStrategy(const MultiThreadedStrategy &&) = delete;
+    MultiThreadedStrategy(const MultiThreadedStrategy &)        = delete;
+    MultiThreadedStrategy(const MultiThreadedStrategy &&)       = delete;
     void               operator=(const MultiThreadedStrategy &) = delete;
 
     [[nodiscard]] bool hasAvailableCapacity(const std::vector<std::shared_ptr<Sequence>> &dependents, const std::int64_t requiredCapacity, const std::int64_t cursorValue) const noexcept {
@@ -212,14 +214,14 @@ class MultiThreadedStrategy {
         }
     }
 
-    [[nodiscard]] forceinline bool isAvailable(std::int64_t sequence) const noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE bool isAvailable(std::int64_t sequence) const noexcept {
         const auto index = calculateIndex(sequence);
         const auto flag  = calculateAvailabilityFlag(sequence);
 
         return _availableBuffer[static_cast<std::size_t>(index)] == flag;
     }
 
-    [[nodiscard]] forceinline std::int64_t getHighestPublishedSequence(const std::int64_t lowerBound, const std::int64_t availableSequence) const noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE std::int64_t getHighestPublishedSequence(const std::int64_t lowerBound, const std::int64_t availableSequence) const noexcept {
         for (std::int64_t sequence = lowerBound; sequence <= availableSequence; sequence++) {
             if (!isAvailable(sequence)) {
                 return sequence - 1;
@@ -230,10 +232,10 @@ class MultiThreadedStrategy {
     }
 
 private:
-    void                      setAvailable(std::int64_t sequence) noexcept { setAvailableBufferValue(calculateIndex(sequence), calculateAvailabilityFlag(sequence)); }
-    forceinline void          setAvailableBufferValue(std::size_t index, std::int32_t flag) noexcept { _availableBuffer[index] = flag; }
-    [[nodiscard]] forceinline std::int32_t calculateAvailabilityFlag(const std::int64_t sequence) const noexcept { return static_cast<std::int32_t>(static_cast<std::uint64_t>(sequence) >> _indexShift); }
-    [[nodiscard]] forceinline std::size_t calculateIndex(const std::int64_t sequence) const noexcept { return static_cast<std::size_t>(static_cast<std::int32_t>(sequence) & _indexMask); }
+    void                              setAvailable(std::int64_t sequence) noexcept { setAvailableBufferValue(calculateIndex(sequence), calculateAvailabilityFlag(sequence)); }
+    OPENCMW_FORCEINLINE void          setAvailableBufferValue(std::size_t index, std::int32_t flag) noexcept { _availableBuffer[index] = flag; }
+    [[nodiscard]] OPENCMW_FORCEINLINE std::int32_t calculateAvailabilityFlag(const std::int64_t sequence) const noexcept { return static_cast<std::int32_t>(static_cast<std::uint64_t>(sequence) >> _indexShift); }
+    [[nodiscard]] OPENCMW_FORCEINLINE std::size_t calculateIndex(const std::int64_t sequence) const noexcept { return static_cast<std::size_t>(static_cast<std::int32_t>(sequence) & _indexMask); }
 };
 static_assert(ClaimStrategy<MultiThreadedStrategy<1024, NoWaitStrategy>>);
 

src/disruptor/include/disruptor/RingBuffer.hpp

@@ -49,7 +49,7 @@ class RingBuffer : public EventStore<T>, public std::enable_shared_from_this<Rin
     [[nodiscard]] std::int64_t                              tryNext(std::int32_t n_slots_to_claim = 1) override { return _claimStrategy->tryNext(*_gatingSequences, n_slots_to_claim); }
     [[nodiscard]] std::int64_t                              getRemainingCapacity() const noexcept override { return _claimStrategy->getRemainingCapacity(*_gatingSequences); }
     void                                                    publish(std::int64_t sequence) override { _claimStrategy->publish(sequence); }
-    [[nodiscard]] forceinline bool                          isAvailable(std::int64_t sequence) const noexcept override { return _claimStrategy->isAvailable(sequence); }
+    [[nodiscard]] OPENCMW_FORCEINLINE bool                  isAvailable(std::int64_t sequence) const noexcept override { return _claimStrategy->isAvailable(sequence); }
     [[nodiscard]] std::int64_t                              getHighestPublishedSequence(std::int64_t nextSequence, std::int64_t availableSequence) const noexcept override { return _claimStrategy->getHighestPublishedSequence(nextSequence, availableSequence); }
     [[nodiscard]] std::int64_t                              cursor() const noexcept override { return _cursor->value(); }
     [[nodiscard]] bool                                      isPublished(std::int64_t sequence) const noexcept override { return isAvailable(sequence); }

src/disruptor/include/disruptor/Sequence.hpp

@@ -4,10 +4,11 @@
 #include <algorithm>
 #include <atomic>
 #include <format>
-#include <opencmw.hpp>
 #include <ostream>
 #include <span>
 
+#include <opencmw.hpp>
+
 namespace opencmw::disruptor {
 
 static constexpr const std::size_t  kCacheLine          = 64;
@@ -27,24 +28,24 @@ class Sequence {
     explicit Sequence(std::int64_t initialValue = kInitialCursorValue) noexcept
         : _fieldsValue(initialValue) {}
 
-    [[nodiscard]] forceinline std::int64_t value() const noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE std::int64_t value() const noexcept {
         return std::atomic_load_explicit(&_fieldsValue, std::memory_order_acquire);
     }
 
-    forceinline void setValue(std::int64_t value) noexcept {
+    OPENCMW_FORCEINLINE void setValue(std::int64_t value) noexcept {
         std::atomic_store_explicit(&_fieldsValue, value, std::memory_order_release);
     }
 
-    [[nodiscard]] forceinline bool compareAndSet(std::int64_t expectedSequence, std::int64_t nextSequence) noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE bool compareAndSet(std::int64_t expectedSequence, std::int64_t nextSequence) noexcept {
         // atomically set the value to the given updated value if the current value == the expected value (true, otherwise folse).
         return std::atomic_compare_exchange_strong(&_fieldsValue, &expectedSequence, nextSequence);
     }
 
-    [[nodiscard]] forceinline std::int64_t incrementAndGet() noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE std::int64_t incrementAndGet() noexcept {
         return std::atomic_fetch_add(&_fieldsValue, 1L) + 1L;
     }
 
-    [[nodiscard]] forceinline std::int64_t addAndGet(std::int64_t value) noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE std::int64_t addAndGet(std::int64_t value) noexcept {
         return std::atomic_fetch_add(&_fieldsValue, value) + value;
     }
 };

src/serialiser/include/IoBuffer.hpp

@@ -4,9 +4,6 @@
 #pragma ide diagnostic ignored "cppcoreguidelines-owning-memory"
 #pragma ide diagnostic ignored "UnreachableCode" // -- allow for alternate non-c-style memory management
 
-#include "MultiArray.hpp"
-#include "opencmw.hpp"
-
 #include <format>
 
 #include <algorithm>
@@ -34,6 +31,10 @@ using polymorphic_allocator = std::experimental::pmr::polymorphic_allocator<T>;
 #include <utility>
 #include <vector>
 
+#include <opencmw.hpp>
+
+#include "MultiArray.hpp"
+
 namespace opencmw {
 
 /* special memory resource which explicitly uses malloc, free and allows the containers
@@ -210,7 +211,7 @@ struct IoBuffer {
     }
 
     template<MetaInfo meta = WITH, typename Container>
-    forceinline constexpr void putBoolContainer(const Container &values) noexcept {
+    OPENCMW_FORCEINLINE constexpr void putBoolContainer(const Container &values) noexcept {
         const std::size_t size       = values.size();
         const std::size_t byteToCopy = size * sizeof(bool);
         if constexpr (meta == WITH) {
@@ -308,7 +309,7 @@ struct IoBuffer {
     constexpr void                             clear() noexcept { _position = _size = 0; }
 
     template<bool checkRange = true>
-    forceinline constexpr void skip(int bytes) noexcept(!checkRange) {
+    OPENCMW_FORCEINLINE constexpr void skip(int bytes) noexcept(!checkRange) {
         if constexpr (checkRange) {
             if (_position + static_cast<std::size_t>(bytes) > size()) { // catches both over and underflow
                 throw std::out_of_range(std::format("requested index {} is out-of-range [0,{}]", static_cast<std::ptrdiff_t>(_position) + bytes, _size));
@@ -318,7 +319,7 @@ struct IoBuffer {
     }
 
     template<typename R, bool checkRange = true>
-    forceinline constexpr R &at(const size_t index) noexcept(!checkRange) {
+    OPENCMW_FORCEINLINE constexpr R &at(const size_t index) noexcept(!checkRange) {
         if constexpr (checkRange) {
             if (index >= _size) {
                 throw std::out_of_range(std::format("requested index {} is out-of-range [0,{}]", index, _size));
@@ -351,7 +352,7 @@ struct IoBuffer {
     }
 
     template<MetaInfo meta = WITH, Number I>
-    forceinline constexpr void put(const I &value) noexcept {
+    OPENCMW_FORCEINLINE constexpr void put(const I &value) noexcept {
         constexpr std::size_t byteToCopy = sizeof(I);
         reserve_spare(byteToCopy);
 
@@ -360,7 +361,7 @@ struct IoBuffer {
     }
 
     template<MetaInfo meta = WITH, StringLike I>
-    forceinline constexpr void put(const I &value) noexcept {
+    OPENCMW_FORCEINLINE constexpr void put(const I &value) noexcept {
         const std::size_t bytesToCopy = value.size() * sizeof(char);
         reserve_spare(bytesToCopy + sizeof(int32_t) + sizeof(char)); // educated guess
         if constexpr (meta == WITH) {
@@ -376,24 +377,24 @@ struct IoBuffer {
     }
 
     template<SupportedType I, size_t size>
-    forceinline constexpr void put(I const (&values)[size]) noexcept { put(std::span<const I>(values, size)); } // NOLINT int a[30]; OK <-> std::array<int, 30>
+    OPENCMW_FORCEINLINE constexpr void put(I const (&values)[size]) noexcept { put(std::span<const I>(values, size)); } // NOLINT int a[30]; OK <-> std::array<int, 30>
     template<SupportedType I>
-    forceinline constexpr void put(std::vector<I> const &values) noexcept { put(std::span<const I>(values.data(), values.size())); }
+    OPENCMW_FORCEINLINE constexpr void put(std::vector<I> const &values) noexcept { put(std::span<const I>(values.data(), values.size())); }
     template<SupportedType I, size_t size>
-    forceinline constexpr void put(std::array<I, size> const &values) noexcept { put(std::span<const I>(values.data(), values.size())); }
+    OPENCMW_FORCEINLINE constexpr void put(std::array<I, size> const &values) noexcept { put(std::span<const I>(values.data(), values.size())); }
 
     template<MetaInfo meta = WITH>
-    forceinline constexpr void put(std::vector<bool> const &values) noexcept {
+    OPENCMW_FORCEINLINE constexpr void put(std::vector<bool> const &values) noexcept {
         putBoolContainer<meta>(values);
     }
 
     template<MetaInfo meta = WITH, size_t size>
-    forceinline constexpr void put(std::array<bool, size> const &values) noexcept {
+    OPENCMW_FORCEINLINE constexpr void put(std::array<bool, size> const &values) noexcept {
         putBoolContainer<meta>(values);
     }
 
     template<bool checkRange = true>
-    [[nodiscard]] forceinline constexpr std::string_view asString(const size_t index = 0U, const int requestedSize = -1) const noexcept(!checkRange) {
+    [[nodiscard]] OPENCMW_FORCEINLINE constexpr std::string_view asString(const size_t index = 0U, const int requestedSize = -1) const noexcept(!checkRange) {
         const auto unsigned_size = static_cast<std::size_t>(requestedSize);
         if constexpr (checkRange) {
             if (index > _size) {
@@ -410,7 +411,7 @@ struct IoBuffer {
     }
 
     template<typename R, typename RawType = std::remove_cvref_t<R>>
-    [[nodiscard]] forceinline constexpr R get() const noexcept {
+    [[nodiscard]] OPENCMW_FORCEINLINE constexpr R get() const noexcept {
         if constexpr (Number<R>) {
             const std::size_t localPosition = _position;
             _position += sizeof(R);
@@ -427,7 +428,7 @@ struct IoBuffer {
     }
 
     template<ArrayOrVector Container, bool checkRange = false>
-    forceinline constexpr Container &getArray(Container &input, const std::size_t requestedSize = SIZE_MAX) const noexcept(!checkRange) {
+    OPENCMW_FORCEINLINE constexpr Container &getArray(Container &input, const std::size_t requestedSize = SIZE_MAX) const noexcept(!checkRange) {
         using R                        = Container::value_type;
         const auto        arraySize    = std::min(static_cast<std::size_t>(get<int32_t>()), _size - _position);
         const std::size_t minArraySize = std::min(arraySize, requestedSize);
@@ -456,14 +457,14 @@ struct IoBuffer {
     }
 
     template<SupportedType R>
-    forceinline constexpr std::vector<R> getArray(std::vector<R> &&input = std::vector<R>(), const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(input, requestedSize); }
+    OPENCMW_FORCEINLINE constexpr std::vector<R> getArray(std::vector<R> &&input = std::vector<R>(), const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(input, requestedSize); }
     template<SupportedType R, std::size_t size>
-    [[maybe_unused]] forceinline constexpr std::array<R, size> getArray(std::array<R, size> &&input = std::array<R, size>(), const std::size_t requestedSize = size) noexcept { return getArray(input, requestedSize); }
+    [[maybe_unused]] OPENCMW_FORCEINLINE constexpr std::array<R, size> getArray(std::array<R, size> &&input = std::array<R, size>(), const std::size_t requestedSize = size) noexcept { return getArray(input, requestedSize); }
 
     template<StringArray R, typename T = typename R::value_type>
-    [[nodiscard]] forceinline constexpr R &get(R &input, const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(input, requestedSize); }
+    [[nodiscard]] OPENCMW_FORCEINLINE constexpr R &get(R &input, const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(input, requestedSize); }
     template<StringArray R, typename T = typename R::value_type>
-    [[nodiscard]] forceinline constexpr R get(R &&input = R(), const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(std::forward<R>(input), requestedSize); }
+    [[nodiscard]] OPENCMW_FORCEINLINE constexpr R get(R &&input = R(), const std::size_t requestedSize = SIZE_MAX) noexcept { return getArray(std::forward<R>(input), requestedSize); }
 };
 
 } // namespace opencmw

src/serialiser/include/IoSerialiser.hpp

@@ -1,12 +1,15 @@
 #ifndef OPENCMW_IOSERIALISER_H
 #define OPENCMW_IOSERIALISER_H
 
-#include "IoBuffer.hpp"
-#include "MultiArray.hpp"
 #include <list>
 #include <map>
 #include <queue>
 
+#include "IoBuffer.hpp"
+#include "MultiArray.hpp"
+
+#include <opencmw.hpp>
+
 #pragma clang diagnostic push
 #pragma ide diagnostic ignored "cppcoreguidelines-avoid-magic-numbers"
 #pragma ide diagnostic ignored "cppcoreguidelines-avoid-c-arrays"
@@ -144,7 +147,7 @@ struct IoSerialiser {
 };
 
 template<ReflectableClass T>
-forceinline int32_t findMemberIndex(const std::string_view &fieldName) noexcept {
+OPENCMW_FORCEINLINE int32_t findMemberIndex(const std::string_view &fieldName) noexcept {
     static constexpr ConstExprMap<std::string_view, int32_t, refl::reflect<T>().members.size> m{ refl::util::map_to_array<std::pair<std::string_view, int32_t>>(refl::reflect<T>().members, [](auto field, auto index) {
         return std::pair<std::string_view, int32_t>(field.name.c_str(), index);
     }) };
@@ -232,7 +235,7 @@ struct FieldHeaderReader {
 
 namespace detail {
 
-forceinline void moveToFieldEndBufferPosition(IoBuffer &buffer, const FieldDescriptionLong &field) {
+OPENCMW_FORCEINLINE void moveToFieldEndBufferPosition(IoBuffer &buffer, const FieldDescriptionLong &field) {
     if (field.dataEndPosition != std::numeric_limits<size_t>::max()) {
         buffer.set_position(field.dataEndPosition);
     }