iox-eclipse-iceoryx#1732 Move static_storage to iceoryx_dust

Signed-off-by: Marika Lehmann <[email protected]>
ApexAI · Jan 18, 2023 · ae2f65f · ae2f65f
1 parent efe93d4
commit ae2f65f
Show file tree

Hide file tree

Showing 14 changed files with 58 additions and 30 deletions.
diff --git a/doc/website/release-notes/iceoryx-unreleased.md b/doc/website/release-notes/iceoryx-unreleased.md
@@ -31,6 +31,7 @@
 - Support user defined platforms with cmake switch `-DIOX_PLATFORM_PATH` [\#1619](https://github.com/eclipse-iceoryx/iceoryx/issues/1619)
 - Add equality and inequality operators for `iox::variant` and `iox::expected` [\#1751](https://github.com/eclipse-iceoryx/iceoryx/issues/1751)
 - Implement UninitializedArray [\#1614](https://github.com/eclipse-iceoryx/iceoryx/issues/1614)
+- Implement BumpAllocator [\#1732](https://github.com/eclipse-iceoryx/iceoryx/issues/1732)
 
 **Bugfixes:**
 
@@ -106,6 +107,7 @@
 - Change return type of `cxx::variant::emplace_at_index` and `emplace` to void [\#1394](https://github.com/eclipse-iceoryx/iceoryx/issues/1394)
 - Replace uses of `std::cout`, `std::cerr` with the iceoryx logger [\#1756](https://github.com/eclipse-iceoryx/iceoryx/issues/1756)
 - Move `IOX_NO_DISCARD`, `IOX_FALLTHROUGH` and `IOX_MAYBE_UNUSED` to `iceoryx_platform` [\#1726](https://github.com/eclipse-iceoryx/iceoryx/issues/1726)
+- Move `cxx::static_storage` from `iceoryx_hoofs` to `iceoryx_dust` [\#1732](https://github.com/eclipse-iceoryx/iceoryx/issues/1732)
 
 **Workflow:**
 
@@ -808,3 +810,14 @@
     iox::UninitializedArray<T, Capacity> myAlignedArray;
 
     ```
+
+42. Move `static_storage` from `iceoryx_hoofs` to `iceoryx_dust`
+
+    ```cpp
+    // before
+    #include "iceoryx_hoofs/internal/cxx/static_storage.hpp"
+
+    // after
+    #include "iceoryx_dust/internal/cxx/static_storage.hpp"
+    ```
+
diff --git a/iceoryx_dust/README.md b/iceoryx_dust/README.md
@@ -16,3 +16,4 @@ grouped together in categories or namespace, depending on where or how they are
 |`SignalWatcher`        | Batteries included signal handling with polling and optional blocking wait for `SIGINT` and `SIGTERM`.                  |
 |`NamedPipe`            | Shared memory based ipc channel. Mainly a `UnixDomainSocket` replacement on Windows.                                    |
 |`relocatable_ptr`      |                                                                                                                         |
+|`static_storage`       | Untyped aligned static storage.                                                                                         |
diff --git a/...ryx_hoofs/internal/cxx/static_storage.hpp → ...oryx_dust/internal/cxx/static_storage.hpp b/...ryx_hoofs/internal/cxx/static_storage.hpp → ...oryx_dust/internal/cxx/static_storage.hpp
@@ -14,8 +14,8 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#ifndef IOX_HOOFS_STATIC_STORAGE_HPP
-#define IOX_HOOFS_STATIC_STORAGE_HPP
+#ifndef IOX_DUST_STATIC_STORAGE_HPP
+#define IOX_DUST_STATIC_STORAGE_HPP
 
 #include <cstdint>
 #include <cstring>
@@ -109,5 +109,5 @@ class static_storage final
 } // namespace cxx
 } // namespace iox
 
-#include "iceoryx_hoofs/internal/cxx/static_storage.inl"
-#endif // IOX_HOOFS_STATIC_STORAGE_HPP
+#include "iceoryx_dust/internal/cxx/static_storage.inl"
+#endif // IOX_DUST_STATIC_STORAGE_HPP
diff --git a/...ryx_hoofs/internal/cxx/static_storage.inl → ...oryx_dust/internal/cxx/static_storage.inl b/...ryx_hoofs/internal/cxx/static_storage.inl → ...oryx_dust/internal/cxx/static_storage.inl
@@ -14,10 +14,10 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#ifndef IOX_HOOFS_CXX_STATIC_STORAGE_INL
-#define IOX_HOOFS_CXX_STATIC_STORAGE_INL
+#ifndef IOX_DUST_CXX_STATIC_STORAGE_INL
+#define IOX_DUST_CXX_STATIC_STORAGE_INL
 
-#include "iceoryx_hoofs/internal/cxx/static_storage.hpp"
+#include "iceoryx_dust/internal/cxx/static_storage.hpp"
 
 namespace iox
 {
@@ -113,4 +113,4 @@ constexpr uint64_t static_storage<Capacity, Align>::allocation_size() noexcept
 } // namespace iox
 
 
-#endif // IOX_HOOFS_STATIC_STORAGE_INL
+#endif // IOX_DUST_STATIC_STORAGE_INL
diff --git a/.../test/moduletests/test_static_storage.cpp → .../test/moduletests/test_static_storage.cpp b/.../test/moduletests/test_static_storage.cpp → .../test/moduletests/test_static_storage.cpp
@@ -14,7 +14,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
-#include "iceoryx_hoofs/internal/cxx/static_storage.hpp"
+#include "iceoryx_dust/internal/cxx/static_storage.hpp"
 #include "test.hpp"
 
 #include <iostream>
@@ -246,5 +246,4 @@ TEST(static_storage_test, AllocationSizeReturnsMoreThanSizeIfTypeIsNotAlignedWit
     EXPECT_EQ(size, sizeof(Data) + typeAlign - storageAlign);
 }
 
-
 } // namespace
diff --git a/iceoryx_hoofs/README.md b/iceoryx_hoofs/README.md
@@ -32,8 +32,8 @@ The module structure is a logical grouping. It is replicated for `concurrent` an
 |`RelativePointer`                   |          | Pointer which can be stored in shared memory                                                                                                                                                                             |
 |`ScopeGuard`                        |          | This is an abstraction of the C++ RAII idiom. Sometimes you have constructs where you would like to perform a certain task on creation and then again when they are getting out of scope, this is where `ScopeGuard` comes in. It is like a `std::lock_guard` or a `std::shared_ptr` but more generic. |
 |`scoped_static`                     |          | Helper function to limit lifetime of static or global variables to a scope                                                                                                                                               |
-|`static_storage`                    | i        | Untyped aligned static storage.                                                                                                                                                                                          |
 |`shared_memory_object/Allocator`    | i        | Helper class for the `SharedMemoryObject`.                                                                                                                                                                               |
+|`BumpAllocator`                     | i        | Implementation of a bump allocator                                                                                                                                                                                       |
 
 ### Container (container)
 

diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/cxx/function.hpp b/iceoryx_hoofs/include/iceoryx_hoofs/cxx/function.hpp
@@ -17,7 +17,6 @@
 #ifndef IOX_HOOFS_FUNCTION_HPP
 #define IOX_HOOFS_FUNCTION_HPP
 
-#include "iceoryx_hoofs/internal/cxx/static_storage.hpp"
 #include "iceoryx_hoofs/internal/cxx/storable_function.hpp"
 
 namespace iox

diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/storable_function.hpp b/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/storable_function.hpp
@@ -19,7 +19,6 @@
 
 #include "iceoryx_hoofs/cxx/type_traits.hpp"
 #include "iceoryx_hoofs/iceoryx_hoofs_types.hpp"
-#include "iceoryx_hoofs/internal/cxx/static_storage.hpp"
 
 #include <iostream>
 #include <utility>
@@ -49,7 +48,6 @@ template <uint64_t Capacity, typename ReturnType, typename... Args>
 class storable_function<Capacity, signature<ReturnType, Args...>> final
 {
   public:
-    using StorageType = static_storage<Capacity>;
     using signature_t = signature<ReturnType, Args...>;
 
     /// @brief construct from functor (including lambdas)

diff --git a/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/storable_function.inl b/iceoryx_hoofs/include/iceoryx_hoofs/internal/cxx/storable_function.inl
@@ -26,6 +26,7 @@ namespace iox
 namespace cxx
 {
 // AXIVION Next Construct AutosarC++19_03-A12.6.1: members are initialized in body before read access
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 template <typename Functor, typename>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(const Functor& functor) noexcept
@@ -35,9 +36,10 @@ inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_fun
 
 // AXIVION Next Construct AutosarC++19_03-A12.1.5: constructor delegation is not feasible here due
 // to lack of sufficient common initialization
-// AXIVION Next Construct AutosarC++19_03-A12.6.1: members are default initialized
 // AXIVION Next Construct AutosarC++19_03-M5.2.6: the converted pointer is only used
 // as its original function pointer type after reconversion (type erasure)
+// AXIVION Next Construct AutosarC++19_03-A12.6.1: members are default initialized
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(
     ReturnType (*function)(Args...)) noexcept
@@ -56,6 +58,7 @@ inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_fun
 }
 
 // AXIVION Next Construct AutosarC++19_03-A12.6.1: members are default initialized
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 template <typename T, typename>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(
@@ -69,6 +72,7 @@ inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_fun
 }
 
 // AXIVION Next Construct AutosarC++19_03-A12.6.1: members are default initialized
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 template <typename T, typename>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(const T& object,
@@ -83,6 +87,7 @@ inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_fun
 }
 
 // AXIVION Next Construct AutosarC++19_03-A12.6.1: m_storage is default initialized
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(
     const storable_function& other) noexcept
@@ -92,9 +97,10 @@ inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_fun
     m_operations.copy(other, *this);
 }
 
-// AXIVION Next Construct AutosarC++19_03-A12.6.1: m_storage is default initialized
 // AXIVION Next Construct AutosarC++19_03-A12.8.4: we copy only the operation pointer table
 // (required) and will perform a move with its type erased move function
+// AXIVION Next Construct AutosarC++19_03-A12.6.1: m_storage is default initialized
+// @NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init, hicpp-member-init)
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 inline storable_function<Capacity, signature<ReturnType, Args...>>::storable_function(
     storable_function&& other) noexcept
@@ -169,11 +175,13 @@ inline void swap(storable_function<Capacity, T>& f, storable_function<Capacity,
 template <typename T>
 void* allocate(byte_t* startAddress, uint64_t Capacity)
 {
-    // static_assert: startAddress + size < Capacity
-    uint64_t alignedPosition = cxx::align(reinterpret_cast<uint64_t>(startAddress), alignof(T));
+    // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast, performance-no-int-to-ptr) required for low level pointer alignment
+    uint64_t alignment = alignof(T);
+    uint64_t alignedPosition = cxx::align(reinterpret_cast<uint64_t>(startAddress), alignment);
     cxx::Expects(alignedPosition + sizeof(T) - reinterpret_cast<uint64_t>(startAddress) < Capacity
                  && "type does not fit into storage");
     return reinterpret_cast<void*>(alignedPosition);
+    // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast, performance-no-int-to-ptr) required for low level pointer alignment
 }
 
 template <uint64_t Capacity, typename ReturnType, typename... Args>
@@ -204,6 +212,7 @@ inline void storable_function<Capacity, signature<ReturnType, Args...>>::copy(co
     const auto obj = static_cast<CallableType*>(src.m_callable);
     cxx::Expects(obj != nullptr); // should not happen unless src is incorrectly used after move
 
+    // NOLINTNEXTLINE(clang-analyzer-core.NonNullParamChecker) checked two lines above
     new (dest.m_callable) CallableType(*obj);
     dest.m_invoker = src.m_invoker;
 }
@@ -215,13 +224,13 @@ template <typename CallableType>
 inline void storable_function<Capacity, signature<ReturnType, Args...>>::move(storable_function& src,
                                                                               storable_function& dest) noexcept
 {
-    //  m_callable = static_cast<void*>(align(reinterpret_cast<uint64_t>(m_storage), alignof(CallableType)));
     dest.m_callable = allocate<CallableType>(dest.m_storage, Capacity);
 
     // AXIVION Next Construct AutosarC++19_03-M5.2.8: type erasure - conversion to compatible type
     const auto obj = static_cast<CallableType*>(src.m_callable);
     cxx::Expects(obj != nullptr); // should not happen unless src is incorrectly used after move
 
+    // NOLINTNEXTLINE(clang-analyzer-core.NonNullParamChecker) checked two lines above
     new (dest.m_callable) CallableType(std::move(*obj));
     dest.m_invoker = src.m_invoker;
     src.m_operations.destroy(src);
@@ -272,9 +281,10 @@ inline ReturnType storable_function<Capacity, signature<ReturnType, Args...>>::i
                                                                                       Args&&... args) noexcept
 {
     // AXIVION Next Construct AutosarC++19_03-A18.9.2: we use idiomatic perfect forwarding
+    // AXIVION Next Construct AutosarC++19_03-M5.2.8: type erasure - conversion to compatible type
     // AXIVION Next Construct AutosarC++19_03-A5.3.2: callable is guaranteed not to be nullptr
     // when invoke is called (it is private and only used for type erasure)
-    // AXIVION Next Construct AutosarC++19_03-M5.2.8: type erasure - conversion to compatible type
+    // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage) see justification above
     return (*static_cast<CallableType*>(callable))(std::forward<Args>(args)...);
 }
 
@@ -301,15 +311,14 @@ template <uint64_t Capacity, typename ReturnType, typename... Args>
 template <typename T>
 inline constexpr uint64_t storable_function<Capacity, signature<ReturnType, Args...>>::required_storage_size() noexcept
 {
-    // return StorageType::template allocation_size<T>();
     return sizeof(T) + alignof(T);
 }
 
 template <uint64_t Capacity, typename ReturnType, typename... Args>
 template <typename T>
 inline constexpr bool storable_function<Capacity, signature<ReturnType, Args...>>::is_storable() noexcept
 {
-    return (required_storage_size<T>() <= StorageType::capacity()) && is_invocable_r<ReturnType, T, Args...>::value;
+    return (required_storage_size<T>() <= Capacity) && is_invocable_r<ReturnType, T, Args...>::value;
 }
 
 template <uint64_t Capacity, typename ReturnType, typename... Args>

diff --git a/iceoryx_hoofs/memory/include/iox/bump_allocator.hpp b/iceoryx_hoofs/memory/include/iox/bump_allocator.hpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2019 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

diff --git a/iceoryx_hoofs/test/moduletests/test_cxx_function.cpp b/iceoryx_hoofs/test/moduletests/test_cxx_function.cpp
@@ -15,6 +15,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "iceoryx_hoofs/cxx/function.hpp"
+#include "iox/bump_allocator.hpp"
 #include "test.hpp"
 
 #include <functional>
@@ -252,9 +253,16 @@ TEST_F(function_test, ConstructionFromAnotherFunctionIsCallable)
 TEST_F(function_test, FunctionStateIsIndependentOfSource)
 {
     ::testing::Test::RecordProperty("TEST_ID", "8302046f-cd6a-4527-aca6-3e6408f87a6b");
-    constexpr uint32_t INITIAL_STATE = 73U;
-    static_storage<1024U> storage;
-    auto* p = storage.allocate<Functor>();
+    constexpr uint32_t INITIAL_STATE = 73;
+    constexpr uint32_t MEMORY_SIZE = 1024;
+
+    // NOLINTNEXTLINE(hicpp-no-malloc, cppcoreguidelines-no-malloc) low-level memory management for testing purpose
+    void* memory = malloc(MEMORY_SIZE);
+    iox::BumpAllocator storage(memory, MEMORY_SIZE);
+    auto allocationResult = storage.allocate(sizeof(Functor), alignof(Functor));
+    ASSERT_FALSE(allocationResult.has_error());
+
+    auto* p = static_cast<Functor*>(allocationResult.value());
     p = new (p) Functor(INITIAL_STATE);
 
     // call the dtor in any case (even if the test fails due to ASSERT)
@@ -270,7 +278,8 @@ TEST_F(function_test, FunctionStateIsIndependentOfSource)
     EXPECT_EQ(sut(1U), functor(1U));
 
     guard.reset(); // call the deleter
-    storage.clear();
+    // NOLINTNEXTLINE(hicpp-no-malloc, cppcoreguidelines-no-malloc) low-level memory management for testing purpose
+    free(memory);
 
     EXPECT_EQ(sut(1U), INITIAL_STATE + 2U);
 }

diff --git a/iceoryx_hoofs/test/moduletests/test_memory_bump_allocator.cpp b/iceoryx_hoofs/test/moduletests/test_memory_bump_allocator.cpp
@@ -124,7 +124,7 @@ TEST_F(BumpAllocator_Test, allocateElementOfSizeZero)
     // @todo iox-#1613 remove EXPECT_DEATH
     // NOLINTBEGIN(hicpp-avoid-goto, cppcoreguidelines-avoid-goto, cert-err33-c, cppcoreguidelines-pro-type-vararg,
     // hiccpp-vararg)
-    EXPECT_DEATH(sut.allocate(0, MEMORY_ALIGNMENT), ".*");
+    EXPECT_DEATH(IOX_DISCARD_RESULT(sut.allocate(0, MEMORY_ALIGNMENT)), ".*");
     // NOLINTEND(hicpp-avoid-goto, cppcoreguidelines-avoid-goto, cert-err33-c, cppcoreguidelines-pro-type-vararg,
     // hiccpp-vararg)
 }

diff --git a/iceoryx_posh/source/roudi/memory/mempool_collection_memory_block.cpp b/iceoryx_posh/source/roudi/memory/mempool_collection_memory_block.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

diff --git a/iceoryx_posh/source/roudi/memory/mempool_segment_manager_memory_block.cpp b/iceoryx_posh/source/roudi/memory/mempool_segment_manager_memory_block.cpp
@@ -1,5 +1,5 @@
 // Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
-// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
+// Copyright (c) 2021 - 2022 by Apex.AI Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.