MemoryPool.h

Go to the documentation of this file.

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef MEMORY_POOL_H
#define MEMORY_POOL_H
 
#include <vector>
#include <exception>
#include <mutex>
#include <memory>
#include <unordered_map>
#include <typeindex>
#include <typeinfo>
 
#include "Utils.h"
#include "Logger.h"
 
typedef struct _memoryNode {
    _memoryNode* next;
    void* block;
} MemoryNode;
 
class MemoryPool {
private:
    static std::shared_ptr<MemoryPool> mMemoryPoolInstance;
    std::mutex mMemoryPoolMutex;
 
    MemoryNode* mFreeListHead;
    MemoryNode* mFreeListTail;
    MemoryNode* mAllocatedListHead;
 
    int32_t mBlockSize;
    int32_t mfreeBlocks;
 
    int32_t addNodesToFreeList(int32_t blockCount);
 
public:
    MemoryPool(int32_t blockSize);
    ~MemoryPool();
 
    int32_t makeAllocation(int32_t blockCount);
 
    void* getBlock();
 
    void freeBlock(void* block);
};
 
class PoolWrapper {
private:
    std::unordered_map<std::type_index, MemoryPool*> mMemoryPoolRefs;
    std::mutex mPoolWrapperMutex;
 
    MemoryPool* getMemoryPool(std::type_index typeIndex);
 
    int32_t makeAllocation(int32_t blockCount, int32_t blockSize, std::type_index typeIndex);
    void* getBlock(int32_t blockSize, std::type_index typeIndex);
    void freeBlock(std::type_index typeIndex, void* block);
 
public:
    PoolWrapper() {}
    ~PoolWrapper() {}
 
    template <typename T>
    int32_t makeAllocation(int32_t blockCount) {
        return makeAllocation(blockCount, sizeof(T), std::type_index(typeid(T)));
    }
 
    template <typename T>
    void* getBlock() {
        return getBlock(sizeof(T), std::type_index(typeid(T)));
    }
 
    template<typename T>
    typename std::enable_if<std::is_class<T>::value, void>::type
    freeBlock(void* block) {
        reinterpret_cast<T*>(block)->~T();
        freeBlock(std::type_index(typeid(T)), block);
    }
 
    template<typename T>
    typename std::enable_if<!std::is_class<T>::value, void>::type
    freeBlock(void* block) {
        freeBlock(std::type_index(typeid(T)), block);
    }
};
 
std::shared_ptr<PoolWrapper> getPoolWrapper();
 
template <typename T>
inline void MakeAlloc(int32_t blockCount) {
    getPoolWrapper()->makeAllocation<T>(blockCount);
}
 
template <typename T>
inline void* GetBlock() {
    return getPoolWrapper()->getBlock<T>();
}
 
template <typename T>
inline void FreeBlock(void* block) {
    getPoolWrapper()->freeBlock<T>(block);
}
 
#endif