PoolAllocator.h

Go to the documentation of this file.

// (c) IMT - Information Management Technology AG, CH-9470 Buchs, www.imt.ch.
//
// ActiveParts (AP) and the corresponding Data Flow Framework (DFF) is invented and designed by Jakob Daescher.
// ANY USE OF THIS CODE CONSTITUTES ACCEPTANCE OF THE TERMS OF THE COPYRIGHT NOTICE.
// ===================================================================================================
// COPYRIGHT NOTICE
// ===================================================================================================
// Copyright (C) 2005-2075, IMT Information Management Technology AG, 9470 Buchs, Switzerland
// All rights reserved.
// This code is proprietary software of IMT Information Management Technology AG (hereinafter: "IMT").
// Proprietary software is computer software licensed under exclusive legal right of IMT.
//
// The licensee is given the irrevocable, perpetual, worldwide, non-exclusive right and license to use,
// execute and reproduce the software in binary form within the licensed products.
//
// Redistribution and use in source forms, without modification, are permitted provided that the following conditions are met:
// (1) Copying of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// (2) Copying of source code is only allowed for regulatory documentation and archiving purposes
// (3) Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
//
// IMT provide no reassurances that the source code provided does not infringe
// any patent, copyright, or any other intellectual property rights of third parties.
// IMT disclaim any liability to any recipient for claims brought against
// recipient by any third party for infringement of that parties intellectual property rights.
//
// THIS SOFTWARE IS PROVIDED BY IMT AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL IMT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
// OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCURE-MENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
// IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ===================================================================================================
 
#ifndef IMT_BASE_CORE_UTIL_POOL_ALLOCATOR_H
#define IMT_BASE_CORE_UTIL_POOL_ALLOCATOR_H
 
#include <array>
#include <Imt.Base.Core.Diagnostics/Diagnostics.h>
#include <Imt.Base.Core.Platform/Platform.h>
#include <new>
#include <type_traits>
 
namespace imt {
namespace base {
namespace core {
namespace util {
 
template<typename T>
class PoolAllocator {
public:
 
    // AXIVION Next Codeline AutosarC++19_03-A18.1.1: use C-style array for compatibility
    PoolAllocator(T pool[], size_t poolSize) noexcept;
 
    T* allocate() noexcept;
 
    void deallocate(T* const obj) noexcept;
 
    bool isFull() const noexcept {
        return m_pFreeList == nullptr;
    }
 
    size_t remainingSize() const noexcept {
        return capacity() - m_itemCount;
    }
 
    void const* endAddr() const noexcept {
        return m_pEndAddr;
    }
 
    void const* startAddr() const noexcept {
        return m_pStartAddr;
    }
 
    size_t capacity() const noexcept {
        return m_capacity;
    }
 
    static size_t getValueSize() noexcept {
        return sizeof(T);
    }
#ifndef _UNITTEST
 
private:
 
#endif
    // AXIVION Next Construct AutosarC++19_03-A9.6.1: the static_assert checks belows are used to check the required conditions regarding pointer size
    // AXIVION Next Construct AutosarC++19_03-A9.5.1: Allowed usage
    // AXIVION Next Construct AutosarC++19_03-M3.2.2: how can the ODR (one definition rule) be violated with sizeof(T), there is no possibility that its different, else it is not the same PoolAllocator template instance
    union Node {
        // AXIVION Construct AutosarC++19_03-A2.7.3: Allowed missing comments, only local relevance
        // AXIVION Construct AutosarC++19_03-M0.1.3: required construct, because Node must have the size of T
        std::array<uint8_t, sizeof(T)> m_data;
        Node* m_pNext;
    };
    // AXIVION Next Construct AutosarC++19_03-A2.7.3: Allowed missing comments, only private relevance
    // AXIVION Next Construct AutosarC++19_03-M11.0.1: Allowed here, not private only for test reasons
    Node* m_pFreeList;
 
    // AXIVION Next Line AutosarC++19_03-M11.0.1: Allowed here, not private only for test reasons
    void const* m_pEndAddr;
    // AXIVION Next Construct AutosarC++19_03-A2.7.3: Allowed missing comments, only private relevance
    // AXIVION Next Construct AutosarC++19_03-M11.0.1: Allowed here, not private only for test reasons
    void const* m_pStartAddr;
    // AXIVION Next Construct AutosarC++19_03-A2.7.3: Allowed missing comments, only private relevance
    // AXIVION Next Construct AutosarC++19_03-M11.0.1: Allowed here, not private only for test reasons
    size_t const m_capacity;
    // AXIVION Next Construct AutosarC++19_03-A2.7.3: Allowed missing comments, only private relevance
    // AXIVION Next Construct AutosarC++19_03-M11.0.1: Allowed here, not private only for test reasons
    // AXIVION Next Construct AutosarC++19_03-A12.1.3: All data members initialized in custom constructor and would collide with AutosarC++19_03-A12.1.2
    std::size_t m_itemCount;
 
    // Assertion used to ensure that the size of T is equal to the size of Node. If this is not the case,
    // please refer the alignment of T. The alignment of T must be at least equal or greater than the alignment
    // of Node*. One exception is if the size is dividable by sizeof(Node*).
    static_assert(sizeof(T) == sizeof(Node), "Node size missmatch");
    static_assert(sizeof(T) >= sizeof(Node*), "Node size missmatch");
};
 
template<typename T>
// AXIVION Next Routine AutosarC++19_03-M5.0.15: Allowed usage, because the m_pFreeList is used for an array only
// AXIVION Next Codeline AutosarC++19_03-A18.1.1: use C-style array for compatibility
PoolAllocator<T>::PoolAllocator(T pool[], size_t poolSize) noexcept :
    // AXIVION Next Line AutosarC++19_03-A5.2.4: Allowed construct, static asserts ensures that a T and Node has the same size and that the size of T is greater or equivalent than the size of Node*.
    m_pFreeList {reinterpret_cast<Node*>(pool)},
    // AXIVION Next Line AutosarC++19_03-M5.0.16 / AutosarC++19_03-A5.2.5: required construct, the end address points to the first address after the pool section
    m_pEndAddr {&pool[poolSize]}, // AXIVION Line AutosarC++19_03-A5.3.2 : NULL pointer check is made in the constructor instruction block at first line
    m_pStartAddr {pool},
    m_capacity {poolSize},
    m_itemCount {0} {
    memset(pool, 0, poolSize);
    ASSERT_EX(nullptr != pool);
    if (m_pFreeList != nullptr) {
        // link array elements together
        for (size_t i {0}; i < (poolSize - 1); ++i) {
            // AXIVION Next Codeline AutosarC++19_03-M5.0.16 / AutosarC++19_03-A5.2.5: poolSize matches with length of the pool array
            m_pFreeList[i].m_pNext = &m_pFreeList[i + 1]; // AXIVION Line AutosarC++19_03-M0.3.1: pointer is not NULL at dereference then checked and also in array bounds
        }
        // AXIVION Next Codeline AutosarC++19_03-M5.0.16 / AutosarC++19_03-A5.2.5 / AutosarC++19_03-M0.3.1: poolSize matches with length of the pool array
        m_pFreeList[poolSize - 1].m_pNext = nullptr;
    }
}
 
template<typename T>
inline T* PoolAllocator<T>::allocate() noexcept {
    if (m_pFreeList == nullptr) {
        return nullptr;
    }
 
    Node* const pNext {m_pFreeList->m_pNext};
 
    if (!std::is_trivially_copyable<T>::value) {
        // AXIVION Next Codeline AutosarC++19_03-A18.5.8: Allowed usage, placement new  operator doesn't use dynamic allocation, whilst still allowing proper initialization
        // Axivion Next Codeline AutosarC++19_03-A18.5.2 : placement new operator is allowed within this rule.
        // Axivion Next Codeline AutosarC++19_03-A18.5.8 : placement new operator is allowed within this rule.
        // Axivion Next Codeline AutosarC++19_03-A18.5.10 : m_pFreeList is an array of Node type. With the static assert for Node == T, it is ensured that the alignment must be correct.
        T* const pReturn {new (m_pFreeList) T};
        m_pFreeList = pNext;
        m_itemCount++;
        return pReturn;
    }
    else {
        // Axivion Next Codeline AutosarC++19_03-A18.5.10 : m_pFreeList is an array of Node type. With the static assert for Node == T, it is ensured that the alignment must be correct.
        // Axivion Next Codeline AutosarC++19_03-A5.2.4: Allowed usage, because the T must be valid due to the static_assert
        T* const pReturn {reinterpret_cast<T*>(&m_pFreeList->m_data)};
        m_pFreeList = pNext;
        m_itemCount++;
        return pReturn;
    }
}
 
template<typename T>
inline void PoolAllocator<T>::deallocate(T* const obj) noexcept { // Axivion Line AutosarC++19_03-A8.4.8: false-positive: it is a input parameter
    ASSERT_EX1(nullptr != obj, "passed nullptr to ObjectPoolAllocator::deallocate");
    // AXIVION Construct AutosarC++19_03-M5.0.18: pointer comparision of unrelated pointers required to determine if they are from this allocator
    ASSERT_EX(m_pStartAddr <= obj);
    ASSERT_EX(m_pEndAddr > obj);
 
    if (!std::is_trivially_copyable<T>::value) { // AXIVION Line AutosarC++19_03-M0.1.2, AutosarC++19_03-M0.1.9: condition can be always true in a project
        obj->~T();
    }
    // AXIVION Next Line AutosarC++19_03-A5.2.4: Allowed usage, because the node must be valid due to the static_assert
    Node* const pNode {reinterpret_cast<Node*>(obj)};
    pNode->m_pNext = m_pFreeList; // AXIVION Line AutosarC++19_03-A5.3.2 : pNode NULL check is done via the obj NULL check above
    m_pFreeList = pNode;
    m_itemCount--; // AXIVION Line AutosarC++19_03-A4.7.1 / AutosarC++19_03-M0.3.1: underflow not possible then not more obj can exist then the counter value
}
 
} // namespace util
} // namespace core
} // namespace base
} // namespace imt
 
#endif // IMT_BASE_CORE_UTIL_POOL_ALLOCATOR_H