mem_blocks.h

Go to the documentation of this file.

/*
 * Copyright (c) 2021 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_MEM_BLOCKS_H_
#define ZEPHYR_INCLUDE_SYS_MEM_BLOCKS_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stddef.h>
#include <stdint.h>
 
#include <zephyr/kernel.h>
#include <zephyr/math/ilog2.h>
#include <zephyr/sys/bitarray.h>
#include <zephyr/sys/mem_stats.h>
 
#define MAX_MULTI_ALLOCATORS 8
 
struct sys_mem_blocks;
 
struct sys_multi_mem_blocks;
 
typedef struct sys_mem_blocks sys_mem_blocks_t;
 
typedef struct sys_multi_mem_blocks sys_multi_mem_blocks_t;
 
typedef sys_mem_blocks_t *(*sys_multi_mem_blocks_choice_fn_t)
        (struct sys_multi_mem_blocks *group, void *cfg);
 
struct sys_mem_blocks_info {
        uint32_t num_blocks;       /* Total number of blocks */
        uint8_t  blk_sz_shift;     /* Bit shift for block size */
#ifdef CONFIG_SYS_MEM_BLOCKS_RUNTIME_STATS
        uint32_t used_blocks;      /* Current number of blocks in use */
        uint32_t max_used_blocks;  /* Maximum number of blocks in use */
#endif
};
 
struct sys_mem_blocks {
        struct sys_mem_blocks_info  info;
 
        /* Memory block buffer */
        uint8_t *buffer;
 
        /* Bitmap of allocated blocks */
        sys_bitarray_t *bitmap;
 
#ifdef CONFIG_SYS_MEM_BLOCKS_RUNTIME_STATS
        /* Spinlock guarding access to memory block internals */
        struct k_spinlock  lock;
#endif
#ifdef CONFIG_OBJ_CORE_SYS_MEM_BLOCKS
        struct k_obj_core obj_core;
#endif
};
 
struct sys_multi_mem_blocks {
        /* Number of allocators in this group */
        int num_allocators;
        sys_multi_mem_blocks_choice_fn_t choice_fn;
        sys_mem_blocks_t *allocators[MAX_MULTI_ALLOCATORS];
};
 
#define _SYS_MEM_BLOCKS_DEFINE_WITH_EXT_BUF(name, blk_sz, num_blks, buf, mbmod) \
        _SYS_BITARRAY_DEFINE(_sys_mem_blocks_bitmap_##name,             \
                             num_blks, mbmod);                          \
        mbmod struct sys_mem_blocks name = {                            \
                .info = {num_blks, ilog2(blk_sz)},                      \
                .buffer = buf,                                          \
                .bitmap = &_sys_mem_blocks_bitmap_##name,               \
        };                                                              \
        STRUCT_SECTION_ITERABLE_ALTERNATE(sys_mem_blocks_ptr,           \
                                          sys_mem_blocks *,             \
                                          __##name##_ptr) = &name;      \
        LINKER_KEEP(__##name##_ptr);
 
#define _SYS_MEM_BLOCKS_DEFINE(name, blk_sz, num_blks, balign, mbmod)   \
        mbmod uint8_t __noinit_named(sys_mem_blocks_buf_##name)         \
                __aligned(WB_UP(balign))                                \
                _sys_mem_blocks_buf_##name[num_blks * WB_UP(blk_sz)];   \
        _SYS_MEM_BLOCKS_DEFINE_WITH_EXT_BUF(name, blk_sz, num_blks,     \
                                           _sys_mem_blocks_buf_##name,  \
                                           mbmod);
 
#define SYS_MEM_BLOCKS_DEFINE(name, blk_sz, num_blks, buf_align) \
        _SYS_MEM_BLOCKS_DEFINE(name, blk_sz, num_blks, buf_align,)
 
#define SYS_MEM_BLOCKS_DEFINE_STATIC(name, blk_sz, num_blks, buf_align) \
        _SYS_MEM_BLOCKS_DEFINE(name, blk_sz, num_blks, buf_align, static)
 
 
#define SYS_MEM_BLOCKS_DEFINE_WITH_EXT_BUF(name, blk_sz, num_blks, buf) \
        _SYS_MEM_BLOCKS_DEFINE_WITH_EXT_BUF(name, blk_sz, num_blks, buf,)
 
#define SYS_MEM_BLOCKS_DEFINE_STATIC_WITH_EXT_BUF(name, blk_sz, num_blks, buf) \
        _SYS_MEM_BLOCKS_DEFINE_WITH_EXT_BUF(name, blk_sz, num_blks, buf, static)
 
int sys_mem_blocks_alloc(sys_mem_blocks_t *mem_block, size_t count,
                         void **out_blocks);
 
int sys_mem_blocks_alloc_contiguous(sys_mem_blocks_t *mem_block, size_t count,
                                   void **out_block);
 
int sys_mem_blocks_get(sys_mem_blocks_t *mem_block, void *in_block, size_t count);
 
int sys_mem_blocks_is_region_free(sys_mem_blocks_t *mem_block, void *in_block, size_t count);
 
int sys_mem_blocks_free(sys_mem_blocks_t *mem_block, size_t count,
                        void **in_blocks);
 
int sys_mem_blocks_free_contiguous(sys_mem_blocks_t *mem_block, void *block, size_t count);
 
#ifdef CONFIG_SYS_MEM_BLOCKS_RUNTIME_STATS
int sys_mem_blocks_runtime_stats_get(sys_mem_blocks_t *mem_block,
                                     struct sys_memory_stats *stats);
 
int sys_mem_blocks_runtime_stats_reset_max(sys_mem_blocks_t *mem_block);
#endif
 
void sys_multi_mem_blocks_init(sys_multi_mem_blocks_t *group,
                               sys_multi_mem_blocks_choice_fn_t choice_fn);
 
void sys_multi_mem_blocks_add_allocator(sys_multi_mem_blocks_t *group,
                                        sys_mem_blocks_t *alloc);
 
int sys_multi_mem_blocks_alloc(sys_multi_mem_blocks_t *group,
                               void *cfg, size_t count,
                               void **out_blocks,
                               size_t *blk_size);
 
int sys_multi_mem_blocks_free(sys_multi_mem_blocks_t *group,
                              size_t count, void **in_blocks);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_SYS_MEM_BLOCKS_H_ */