Add convienence functions to MemoryAllocator (#4439)

* Add convienence functions to MemoryAllocator

* Fix comments

Author: LeStarch

Fw/Types/MemAllocator.cpp

@@ -15,6 +15,27 @@ MemAllocator::MemAllocator() {}
 
 MemAllocator::~MemAllocator() {}
 
+void* MemAllocator::allocate(const FwEnumStoreType identifier, FwSizeType& size, FwSizeType alignment) {
+    bool unused = false;
+    return this->allocate(identifier, size, unused, alignment);
+}
+
+void* MemAllocator ::checkedAllocate(const FwEnumStoreType identifier,
+                                     FwSizeType& size,
+                                     bool& recoverable,
+                                     FwSizeType alignment) {
+    FwSizeType requestedSize = size;
+    void* memory = this->allocate(identifier, size, recoverable, alignment);
+    FW_ASSERT(memory != nullptr && size >= requestedSize, static_cast<FwAssertArgType>(identifier),
+              static_cast<FwAssertArgType>(requestedSize), static_cast<FwAssertArgType>(size));
+    return memory;
+}
+
+void* MemAllocator ::checkedAllocate(const FwEnumStoreType identifier, FwSizeType& size, FwSizeType alignment) {
+    bool unused = false;
+    return this->checkedAllocate(identifier, size, unused, alignment);
+}
+
 MemAllocatorRegistry::MemAllocatorRegistry() {
     // Register self as the singleton
     MemAllocatorRegistry::s_registry = this;

Fw/Types/MemAllocator.hpp

@@ -74,6 +74,54 @@ class MemAllocator {
     //! \param ptr the pointer to memory returned by allocate()
     virtual void deallocate(const FwEnumStoreType identifier, void* ptr) = 0;
 
+    //! Allocate memory without recoverable flag
+    //!
+    //! This is a convenience method that calls allocate() without the recoverable flag. The recoverable flag is filled
+    //! by the underlying allocator but is not returned to the caller. This is for cases when the caller does not care
+    //! about recoverability of memory.
+    //!
+    //! \param identifier the memory segment identifier, each identifier is to be used in once single allocation
+    //! \param size the requested size - changed to actual if different
+    //! \param alignment - alignment requirement for the allocation. Default: maximum alignment defined by C++.
+    //! \return the pointer to memory. Zero if unable to allocate
+    void* allocate(const FwEnumStoreType identifier,
+                   FwSizeType& size,
+                   FwSizeType alignment = alignof(std::max_align_t));
+
+    //! Allocate memory checking that the allocation was successful
+    //!
+    //! This is a convenience method that calls allocate() and checks that the returned pointer is not null and that
+    //! size is at least as large as the requested size.
+    //!
+    //! Allocations are checked using FW_ASSERT implying that an allocation failure results in a tripped assertion.
+    //!
+    //! \param identifier the memory segment identifier, each identifier is to be used in once single allocation
+    //! \param size the requested size, actual allocation will be at least this size
+    //! \param recoverable - flag to indicate the memory could be recoverable
+    //! \param alignment - alignment requirement for the allocation. Default: maximum alignment defined by C++.
+    //! \return the pointer to memory. Zero if unable to allocate
+    void* checkedAllocate(const FwEnumStoreType identifier,
+                          FwSizeType& size,
+                          bool& recoverable,
+                          FwSizeType alignment = alignof(std::max_align_t));
+
+    //! Allocate memory checking that the allocation was successful without recoverable flag
+    //!
+    //! This is a convenience method that calls allocate() and checks that the returned pointer is not null and that
+    //! size is at least as large as the requested size. The recoverable flag is filled by the underlying allocator
+    //! but is not returned to the caller. This is for cases when the caller does not care about recoverability of
+    //! memory.
+    //!
+    //! Allocations are checked using FW_ASSERT implying that an allocation failure results in a tripped assertion.
+    //!
+    //! \param identifier the memory segment identifier, each identifier is to be used in once single allocation
+    //! \param size the requested size, actual allocation will be at least this size
+    //! \param alignment - alignment requirement for the allocation. Default: maximum alignment defined by C++.
+    //! \return the pointer to memory. Zero if unable to allocate
+    void* checkedAllocate(const FwEnumStoreType identifier,
+                          FwSizeType& size,
+                          FwSizeType alignment = alignof(std::max_align_t));
+
   protected:
     MemAllocator();
     virtual ~MemAllocator();

Fw/Types/test/ut/TypesTest.cpp

@@ -1588,6 +1588,62 @@ TEST(AllocatorTest, MallocAllocatorTest) {
     allocator.deallocate(100, ptr);
 }
 
+TEST(AllocatorTest, MallocAllocatorTestNoRecoverable) {
+    // Since it is a wrapper around malloc, the test consists of requesting
+    // memory and verifying a non-zero pointer, unchanged size, and not recoverable.
+    Fw::MallocAllocator allocator;
+    Fw::MemAllocator& memAllocator = allocator;
+    FwSizeType size = 100;  // one hundred bytes
+    void* ptr = memAllocator.allocate(10, size);
+    ASSERT_EQ(100, size);
+    ASSERT_NE(ptr, nullptr);
+    // deallocate memory
+    allocator.deallocate(100, ptr);
+}
+
+TEST(AllocatorTest, MallocCheckedAllocate) {
+    // Since it is a wrapper around malloc, the test consists of requesting
+    // memory and verifying a non-zero pointer, unchanged size, and not recoverable.
+    Fw::MallocAllocator allocator;
+    FwSizeType size = 100;  // one hundred bytes
+    bool recoverable;
+    void* ptr = allocator.checkedAllocate(10, size, recoverable);
+    ASSERT_EQ(100, size);
+    ASSERT_NE(ptr, nullptr);
+    ASSERT_FALSE(recoverable);
+    // deallocate memory
+    allocator.deallocate(100, ptr);
+}
+
+TEST(AllocatorTest, MallocCheckedAllocateNoRecoverable) {
+    // Since it is a wrapper around malloc, the test consists of requesting
+    // memory and verifying a non-zero pointer, unchanged size, and not recoverable.
+    Fw::MallocAllocator allocator;
+    FwSizeType size = 100;  // one hundred bytes
+    void* ptr = allocator.checkedAllocate(10, size);
+    ASSERT_EQ(100, size);
+    ASSERT_NE(ptr, nullptr);
+    // deallocate memory
+    allocator.deallocate(100, ptr);
+}
+
+TEST(AllocatorTest, MallocCheckedAllocateTrapped) {
+    // Since it is a wrapper around malloc, the test consists of requesting
+    // memory and verifying a non-zero pointer, unchanged size, and not recoverable.
+    Fw::MallocAllocator allocator;
+    bool recoverable;
+    FwSizeType size = std::numeric_limits<FwSizeType>::max();  // Impossible number of bytes
+    ASSERT_DEATH(allocator.checkedAllocate(10, size, recoverable), ".*");
+}
+
+TEST(AllocatorTest, MallocCheckedAllocateNoRecoverableTrapped) {
+    // Since it is a wrapper around malloc, the test consists of requesting
+    // memory and verifying a non-zero pointer, unchanged size, and not recoverable.
+    Fw::MallocAllocator allocator;
+    FwSizeType size = std::numeric_limits<FwSizeType>::max();  // Impossible number of bytes
+    ASSERT_DEATH(allocator.checkedAllocate(10, size), ".*");
+}
+
 TEST(Nominal, string_copy) {
     const char* copy_string = "abc123\n";  // Length of 7
     char buffer_out_test[10];