util/membag.c

Go to the documentation of this file.

#include <assert.h>
#include <debug.h>
#include <interrupt.h>
#include <util.h>
#include <physmem.h>
#include <string.h>
#include <mempool.h>
#include <membag.h>
#include <app/membag.h>

struct membag {
        size_t block_size; 
        size_t num_blocks; 
        struct physmem_pool *phys_pool; 
        struct mem_pool pool; 

        void *start; 
        void *end; 
#ifdef CONFIG_MEMBAG_USE_TUNING
        struct membag_bagstats stats; 
#endif
};

#define MEMBAG(objsize, nr_objs, pool)                  \
        { .block_size = objsize, .num_blocks = nr_objs, .phys_pool = pool }

static struct membag membags[] = {
        APP_MEMBAG_INITIALIZER
};


static void membag_pool_init_physmem(struct membag *mb, unsigned int align_order)
{
        phys_addr_t     pool_addr;
        size_t          pool_size;
        size_t          block_size;
        void            *pool_vaddr;

        assert(mb);
        assert(mb->phys_pool);
        assert(mb->block_size > 0);
        assert(mb->num_blocks > 0);

        block_size = round_up(mb->block_size, align_order);
        pool_size = mb->num_blocks * block_size;

        pool_addr = physmem_alloc(mb->phys_pool, pool_size, align_order);

        assert(pool_addr != PHYSMEM_ALLOC_ERR);

        pool_vaddr = physmem_map(pool_addr, pool_size,
                        PHYS_MAP_WRBUF | PHYS_MAP_WRBACK);
        mem_pool_init(&mb->pool, pool_vaddr, pool_size, mb->block_size, align_order);
        mb->start = pool_vaddr;
        mb->end = (uint8_t *)pool_vaddr + pool_size;

#ifdef CONFIG_MEMBAG_USE_TUNING
        mb->stats.num_free_blocks = mb->num_blocks;
        mb->stats.max_blocks_used = 0;
        mb->stats.min_block_size = block_size;
        mb->stats.max_block_size = 0;
        mb->stats.num_allocations = 0;
#endif
}


void membag_init(const unsigned int align_order)
{
        uint8_t i;

        // Iterate over all bags and allocate them from physical memory
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                membag_pool_init_physmem(&membags[i], align_order);
        }
}

size_t membag_get_total(void)
{
        size_t total = 0;
        uint16_t blocks;
        uint16_t size;
        uint8_t i;

        // Iterate over all bags and sum the total memory available
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                size = membags[i].block_size;
                blocks = membags[i].num_blocks;
                total += size * blocks;
        }
        return total;
}

#ifdef CONFIG_MEMBAG_USE_TUNING

size_t membag_get_free(void)
{
        size_t free = 0;
        uint8_t i;

        // Iterate over all bags and sum the free memory available
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                free += membags[i].block_size * membags[i].stats.num_free_blocks;
        }

        return free;
}
#endif

size_t membag_get_smallest_free_block_size(void)
{
        uint8_t i;

        // Start at first bag and iterate up to find first available block
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                if (membags[i].pool.freelist) {
                        return membags[i].block_size;
                }
        }
        return 0;
}

size_t membag_get_largest_free_block_size(void)
{
        uint8_t i = ARRAY_LEN(membags);

        // Start at last bag and iterate down to find first available block
        while (i > 0) {
                i--;
                if (membags[i].pool.freelist) {
                        return membags[i].block_size;
                }
        }
        return 0;
}

void *membag_alloc(size_t size)
{
        uint8_t i;
        void *ptr = NULL;

        // Iterate through bags to find smallest available bag
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                // If bag is too small then skip to next bag
                if (membags[i].block_size < size) {
                        continue;
                }

                // Try to allocate memory
                ptr = mem_pool_alloc(&membags[i].pool);

                // If allocation failed we continue to the next bag
                if (ptr == NULL) {
                        continue;
                }

#ifdef CONFIG_MEMBAG_USE_TUNING
                membags[i].stats.num_free_blocks--;

                // Update allocations
                membags[i].stats.num_allocations++;

                // Update high/low watermarks
                if (membags[i].stats.num_allocations >
                                membags[i].stats.max_blocks_used) {
                        membags[i].stats.max_blocks_used =
                                membags[i].stats.num_allocations;
                }

                if (size < membags[i].stats.min_block_size) {
                        membags[i].stats.min_block_size = size;
                }

                if (size > membags[i].stats.max_block_size) {
                        membags[i].stats.max_block_size = size;
                }
#endif

                // Memory has been allocated, skip any further looping
                break;
        }
        return ptr;
}

void membag_free(void *ptr)
{
        uint8_t i;

        // Iterate through bags to free memory in correct bag
        for (i = 0; i < ARRAY_LEN(membags); i++) {
                if ((ptr >= membags[i].start) && (ptr <= membags[i].end)) {
                        // Found correct bag. Free memory and return
                        mem_pool_free(&membags[i].pool, ptr);
#ifdef CONFIG_MEMBAG_USE_TUNING
                        membags[i].stats.num_free_blocks++;
#endif
                        break;
                }
        }
}

#ifdef CONFIG_MEMBAG_USE_TUNING

void membag_get_bag_stats(size_t bag_no, struct membag_bagstats *stats)
{
        assert(bag_no < ARRAY_LEN(membags));

        memcpy(stats, &membags[bag_no].stats, sizeof(struct membag_bagstats));
}
#endif

---