heap_based_pool_allocator.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Pavel Kirienko <pavel.kirienko@gmail.com>
 */

#include <gtest/gtest.h>
#include <uavcan/helpers/heap_based_pool_allocator.hpp>
#ifdef __linux__
#include <malloc.h>

#else
#include <stdlib.h>
#endif

TEST(HeapBasedPoolAllocator, Basic)
{
#ifdef __linux__
    std::cout << ">>> HEAP BEFORE:" << std::endl;
    malloc_stats();
#endif

    uavcan::HeapBasedPoolAllocator<uavcan::MemPoolBlockSize> al(0xEEEE);

    ASSERT_EQ(0, al.getNumReservedBlocks());
    ASSERT_EQ(0, al.getNumAllocatedBlocks());

    ASSERT_EQ(0xEEEE, al.getBlockCapacity());
    ASSERT_EQ(0xFFFF, al.getBlockCapacityHardLimit());

    void* a = al.allocate(10);
    void* b = al.allocate(10);
    void* c = al.allocate(10);
    void* d = al.allocate(10);

    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(4, al.getNumAllocatedBlocks());

    al.deallocate(a);
    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(3, al.getNumAllocatedBlocks());

    al.deallocate(b);
    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(2, al.getNumAllocatedBlocks());

    al.deallocate(c);
    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(1, al.getNumAllocatedBlocks());

    a = al.allocate(10);
    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(2, al.getNumAllocatedBlocks());
    ASSERT_EQ(c, a);

    al.deallocate(a);
    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(1, al.getNumAllocatedBlocks());

    al.shrink();
    ASSERT_EQ(1, al.getNumReservedBlocks());
    ASSERT_EQ(1, al.getNumAllocatedBlocks());

    al.deallocate(d);
    ASSERT_EQ(1, al.getNumReservedBlocks());
    ASSERT_EQ(0, al.getNumAllocatedBlocks());

    al.shrink();
    ASSERT_EQ(0, al.getNumReservedBlocks());
    ASSERT_EQ(0, al.getNumAllocatedBlocks());

#ifdef __linux__
    std::cout << ">>> HEAP AFTER:" << std::endl;
    malloc_stats();
#endif
}


TEST(HeapBasedPoolAllocator, Limits)
{
    uavcan::HeapBasedPoolAllocator<uavcan::MemPoolBlockSize> al(2);

    ASSERT_EQ(2, al.getBlockCapacity());
    ASSERT_EQ(4, al.getBlockCapacityHardLimit());

    ASSERT_EQ(0, al.getNumReservedBlocks());
    ASSERT_EQ(0, al.getNumAllocatedBlocks());

    void* a = al.allocate(10);
    void* b = al.allocate(10);
    void* c = al.allocate(10);
    void* d = al.allocate(10);

    ASSERT_TRUE(a);
    ASSERT_TRUE(b);
    ASSERT_TRUE(c);
    ASSERT_TRUE(d);

    ASSERT_FALSE(al.allocate(10));

    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(4, al.getNumAllocatedBlocks());

    al.deallocate(a);
    al.deallocate(b);
    al.deallocate(c);
    al.deallocate(d);

    ASSERT_EQ(4, al.getNumReservedBlocks());
    ASSERT_EQ(0, al.getNumAllocatedBlocks());
}

#if UAVCAN_CPP_VERSION >= UAVCAN_CPP11

#include <thread>
#include <mutex>

struct RaiiSynchronizer
{
    static std::mutex mutex;
    std::lock_guard<std::mutex> guard{mutex};
};

std::mutex RaiiSynchronizer::mutex;

TEST(HeapBasedPoolAllocator, Concurrency)
{
#ifdef __linux__
    std::cout << ">>> HEAP BEFORE:" << std::endl;
    malloc_stats();

#endif
    uavcan::HeapBasedPoolAllocator<uavcan::MemPoolBlockSize, RaiiSynchronizer> al(1000);

    ASSERT_EQ(1000, al.getBlockCapacity());
    ASSERT_EQ(2000, al.getBlockCapacityHardLimit());

    volatile bool terminate = false;

    /*
     * Starting the testing threads
     */
    std::thread threads[3];

    for (auto& x : threads)
    {
        x = std::thread([&al, &terminate]()
        {
            while (!terminate)
            {
                auto a = al.allocate(1);
                auto b = al.allocate(1);
                auto c = al.allocate(1);
                al.deallocate(al.allocate(1));
                al.deallocate(a);
                al.deallocate(b);
                al.deallocate(c);
            }
        });
    }

    /*
     * Running the threads for some time, then terminating
     */
    std::this_thread::sleep_for(std::chrono::seconds(1));

    terminate = true;
    std::cout << "Terminating workers..." << std::endl;

    for (auto& x : threads)
    {
        x.join();
    }
    std::cout << "All workers joined" << std::endl;

    /*
     * Now, there must not be any leaked memory, because the worker threads deallocate everything before completion.
     */
    std::cout << "Allocated: " << al.getNumAllocatedBlocks() << std::endl;
    std::cout << "Reserved:  " << al.getNumReservedBlocks() << std::endl;

#ifdef __linux__
    std::cout << ">>> HEAP BEFORE SHRINK:" << std::endl;
    malloc_stats();

#endif
    al.shrink();

#ifdef __linux__
    std::cout << ">>> HEAP AFTER SHRINK:" << std::endl;
    malloc_stats();
#endif
}

#endif