objcache.c

浏览该文件的文档.

 
#include <xwos/standard.h>
#include <xwos/lib/xwbop.h>
#include <xwos/lib/xwaop.h>
#include <xwos/lib/bclst.h>
#include <xwos/lib/lfq.h>
#include <xwos/osal/lock/seqlock.h>
#include <xwos/mm/common.h>
#include <xwos/mm/mempool/page.h>
#include <xwos/mm/mempool/objcache.h>
 
/* #define XWMM_MEMPOOLLOGF */ 
#ifdef XWMM_MEMPOOLLOGF
#  define xwmm_mempoollogf(lv, thd, fmt, ...) \
          xwlogf(lv, "Thd:%s", fmt, thd->stack.name, ##__VA_ARGS__)
#else
#  define xwmm_mempoollogf(lv, thd, fmt, ...)
#endif
 
static __xwos_code
void xwmm_mempool_objcache_page_init(struct xwmm_mempool_objcache * oc,
                                     struct xwmm_mempool_page * pg);
 
static __xwos_code
xwsz_t xwmm_mempool_objcache_free_idle_page(struct xwmm_mempool_objcache * oc,
                                            xwsz_t nr);
 
static __xwos_code
void xwmm_mempool_objcache_page_put(struct xwmm_mempool_objcache * oc,
                                    struct xwmm_mempool_page * pg);
 
static __xwos_code
xwer_t xwmm_mempool_objcache_page_get(struct xwmm_mempool_objcache * oc,
                                      struct xwmm_mempool_page ** pgbuf);
 
static __xwos_code
xwer_t xwmm_mempool_objcache_i_a_malloc(void * this, xwsz_t size, void ** membuf);
 
static __xwos_code
xwer_t xwmm_mempool_objcache_i_a_free(void * this, void * mem);
 
__xwos_api
xwer_t xwmm_mempool_objcache_init(struct xwmm_mempool_objcache * oc,
                                  struct xwmm_mempool_page_allocator * pa,
                                  const char * name,
                                  xwsz_t objsize, xwsz_t alignment, xwsq_t pg_order,
                                  ctor_f ctor, dtor_f dtor)
{
        xwsz_t nr;
        xwsz_t pgsize;
 
/*
 * ----------------------------
 * | struct xwmm_mempool_page |
 * -----------------------------------------------------------------------------
 * |  attr.objcache.objhead   |->| obj | a | obj | a | obj | a | ...
 * |--------------------------|-------------------------------------------------
 * | ...                      |        |   ^     |   ^     |   ^
 * |--------------------------|        |___|     |___|     |___|
 * obj: object
 * a: alignment area
 */
 
        alignment = XWBOP_ALIGN(alignment, (xwsz_t)XWMM_ALIGNMENT);
        objsize = XWBOP_ALIGN(objsize, (xwsz_t)alignment);
        if (NULL != ctor) {
                xwu8_t obj[objsize];
                ctor((void *)obj);
                oc->backup = *((xwptr_t *)obj);
        } else {
                oc->backup = 0;
        }
 
        pgsize = pa->pgsize << pg_order;
        nr = pgsize / objsize;
 
        oc->name = name;
        oc->pa = pa;
        oc->objsize = objsize;
        oc->alignment = alignment;
        oc->pg_order = pg_order;
        oc->pg_objnr = nr;
        oc->ctor = ctor;
        oc->dtor = dtor;
        oc->capacity = 0;
        oc->idleness = 0;
        oc->reserved = 0;
        xwlib_bclst_init_head(&oc->page_list.full);
        xwlib_bclst_init_head(&oc->page_list.available);
        xwlib_bclst_init_head(&oc->page_list.idle);
        xwos_sqlk_init(&oc->page_list.lock);
        oc->i_a.malloc = xwmm_mempool_objcache_i_a_malloc;
        oc->i_a.free = xwmm_mempool_objcache_i_a_free;
 
        return XWOK;
}
 
static __xwos_code
void xwmm_mempool_objcache_page_init(struct xwmm_mempool_objcache * oc,
                                     struct xwmm_mempool_page * pg)
{
        xwsz_t i;
        xwsz_t loop;
        xwptr_t curr;
        xwptr_t next;
 
        xwlib_bclst_init_node(&pg->attr.objcache.node);
        pg->attr.objcache.refcnt = 0;
        pg->data.value = oc->objsize;
 
        /* 构造所有对象 */
        if (NULL != oc->ctor) {
                curr = pg->mapping;
                next = curr;
                loop = oc->pg_objnr;
                for (i = 0; i < loop; i++) {
                        next += oc->objsize;
                        oc->ctor((void *)curr);
                        curr = next;
                }
        }
 
        /* 初始化无锁队列 */
        xwlib_lfq_init(&pg->attr.objcache.objhead);
        curr = pg->mapping;
        next = curr;
        loop = oc->pg_objnr;
        for (i = 0; i < loop; i++) {
                next += oc->objsize;
                xwlib_lfq_init((atomic_xwlfq_t *)curr);
                xwlib_lfq_push(&pg->attr.objcache.objhead,
                               (atomic_xwlfq_t *)curr);
                curr = next;
        }
}
 
static __xwos_code
xwsz_t xwmm_mempool_objcache_free_idle_page(struct xwmm_mempool_objcache * oc,
                                            xwsz_t nr)
{
        struct xwmm_mempool_page * pg;
        xwreg_t flag;
        xwsz_t real;
 
        real = 0;
        while (real < nr) {
                xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
                if (xwlib_bclst_tst_empty(&oc->page_list.idle)) {
                        xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
                        break;
                }
                pg = xwlib_bclst_last_entry(&oc->page_list.idle,
                                            struct xwmm_mempool_page,
                                            attr.objcache.node);
                xwlib_bclst_del_init(&pg->attr.objcache.node);
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
                // cppcheck-suppress [misra-c2012-17.7]
                xwmm_mempool_page_free(oc->pa, pg);
                xwaop_sub(xwsz_t, &oc->capacity, oc->pg_objnr, NULL, NULL);
                xwaop_sub(xwsz_t, &oc->idleness, oc->pg_objnr, NULL, NULL);
                real++;
        }
        return real;
}
 
static __xwos_code
void xwmm_mempool_objcache_page_put(struct xwmm_mempool_objcache * oc,
                                    struct xwmm_mempool_page * pg)
{
        xwreg_t flag;
 
        xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
        XWOS_BUG_ON((xwsq_t)0 == pg->attr.objcache.refcnt);
        pg->attr.objcache.refcnt--;
        xwlib_bclst_del_init(&pg->attr.objcache.node);
        if ((xwsq_t)0 == pg->attr.objcache.refcnt) {
                xwlib_bclst_add_head(&oc->page_list.idle,
                                     &pg->attr.objcache.node);
        } else {
                xwlib_bclst_add_head(&oc->page_list.available,
                                     &pg->attr.objcache.node);
        }
        xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
}
 
static __xwos_code
xwer_t xwmm_mempool_objcache_page_get(struct xwmm_mempool_objcache * oc,
                                      struct xwmm_mempool_page ** pgbuf)
{
        struct xwmm_mempool_page * pg;
        xwreg_t flag;
        xwer_t rc;
 
        xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
        if (!xwlib_bclst_tst_empty(&oc->page_list.available)) {
                pg = xwlib_bclst_first_entry(&oc->page_list.available,
                                             struct xwmm_mempool_page,
                                             attr.objcache.node);
                xwlib_bclst_del_init(&pg->attr.objcache.node);
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
        } else if (!xwlib_bclst_tst_empty(&oc->page_list.idle)) {
                pg = xwlib_bclst_first_entry(&oc->page_list.idle,
                                             struct xwmm_mempool_page,
                                             attr.objcache.node);
                xwlib_bclst_del_init(&pg->attr.objcache.node);
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
        } else {
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
                rc = xwmm_mempool_page_allocate(oc->pa, oc->pg_order, &pg);
                if (rc < 0) {
                        goto err_pg_alloc;
                }
                xwaop_add(xwsz_t, &oc->capacity, oc->pg_objnr, NULL, NULL);
                xwaop_add(xwsz_t, &oc->idleness, oc->pg_objnr, NULL, NULL);
                xwmm_mempool_objcache_page_init(oc, pg);
        }
        *pgbuf = pg;
        return XWOK;
 
err_pg_alloc:
        return rc;
}
 
__xwos_api
xwer_t xwmm_mempool_objcache_alloc(struct xwmm_mempool_objcache * oc, void ** objbuf)
{
        struct xwmm_mempool_page * pg;
        xwlfq_t * obj;
        xwreg_t flag;
        xwer_t rc;
 
        rc = xwmm_mempool_objcache_page_get(oc, &pg);
        if (rc < 0) {
                goto err_page_get;
        }
 
        xwaop_sub(xwsz_t, &oc->idleness, 1, NULL, NULL);
        obj = xwlib_lfq_pop(&pg->attr.objcache.objhead);
        XWOS_BUG_ON(NULL == obj);
        *obj = oc->backup;
        *objbuf = (void *)obj;
 
        xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
        XWOS_BUG_ON(pg->attr.objcache.refcnt >= oc->pg_objnr);
        pg->attr.objcache.refcnt++;
        xwlib_bclst_del_init(&pg->attr.objcache.node);
        if (pg->attr.objcache.refcnt == oc->pg_objnr) {
                xwlib_bclst_add_tail(&oc->page_list.full, &pg->attr.objcache.node);
        } else {
                xwlib_bclst_add_head(&oc->page_list.available, &pg->attr.objcache.node);
        }
        xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
 
        return XWOK;
 
err_page_get:
        return rc;
}
 
__xwos_api
xwer_t xwmm_mempool_objcache_free(struct xwmm_mempool_objcache * oc, void * obj)
{
        atomic_xwlfq_t * lfq;
        struct xwmm_mempool_page * pg;
        xwsz_t reserved;
        xwsz_t idleness;
        xwptr_t offset;
        xwptr_t origin;
        xwer_t rc;
 
        rc = xwmm_mempool_page_find(oc->pa, obj, &pg);
        if (rc < 0) {
                goto err_pg_find;
        }
 
        offset = ((xwptr_t)obj - pg->mapping) % oc->objsize;
        origin = (xwptr_t)obj - offset;
        obj = (void *)origin;
 
        if (NULL != oc->dtor) {
                oc->dtor(obj);
        }
 
        lfq = (atomic_xwlfq_t *)obj;
        xwlib_lfq_push(&pg->attr.objcache.objhead, lfq);
 
        xwmm_mempool_objcache_page_put(oc, pg);
        xwaop_add(xwsz_t, &oc->idleness, 1, &idleness, NULL);
        reserved = xwaop_load(xwsz_t, &oc->reserved, xwaop_mo_relaxed);
 
        if ((reserved + oc->pg_objnr) <= idleness) {
                xwsz_t nr;
 
                nr = (idleness - reserved) / oc->pg_objnr;
                // cppcheck-suppress [misra-c2012-17.7]
                xwmm_mempool_objcache_free_idle_page(oc, nr);
        }
 
        return XWOK;
 
err_pg_find:
        return rc;
}
 
__xwos_api
xwer_t xwmm_mempool_objcache_reserve(struct xwmm_mempool_objcache * oc,
                                     xwsz_t reserved)
{
        struct xwmm_mempool_page * pg;
        xwsz_t capacity;
        xwsz_t idleness;
        xwreg_t flag;
        xwer_t rc;
 
        reserved = XWBOP_DIV_ROUND_UP(reserved, oc->pg_objnr);
        xwaop_write(xwsz_t, &oc->reserved, reserved, NULL);
        capacity = xwaop_load(xwsz_t, &oc->capacity, xwaop_mo_relaxed);
        idleness = xwaop_load(xwsz_t, &oc->idleness, xwaop_mo_relaxed);
        if (capacity < reserved) {
                rc = xwmm_mempool_page_allocate(oc->pa, oc->pg_order, &pg);
                if (rc < 0) {
                        goto err_pg_alloc;
                }
                xwaop_add(xwsz_t, &oc->capacity, oc->pg_objnr, NULL, NULL);
                xwaop_add(xwsz_t, &oc->idleness, oc->pg_objnr, NULL, NULL);
                xwmm_mempool_objcache_page_init(oc, pg);
                xwos_sqlk_wr_lock_cpuirqsv(&oc->page_list.lock, &flag);
                xwlib_bclst_add_tail(&oc->page_list.idle, &pg->attr.objcache.node);
                xwos_sqlk_wr_unlock_cpuirqrs(&oc->page_list.lock, flag);
        } else if ((reserved + oc->pg_objnr) < idleness) {
                xwsz_t nr;
 
                nr = (idleness - reserved) / oc->pg_objnr;
                // cppcheck-suppress [misra-c2012-17.7]
                xwmm_mempool_objcache_free_idle_page(oc, nr);
        } else {
        }
        return XWOK;
 
err_pg_alloc:
        return rc;
}
 
__xwos_api
xwer_t xwmm_mempool_objcache_get_capacity(struct xwmm_mempool_objcache * oc,
                                          xwsz_t * capacity)
{
        *capacity = xwaop_load(xwsz_t, &oc->capacity, xwaop_mo_relaxed);
        return XWOK;
}
 
static __xwos_code
xwer_t xwmm_mempool_objcache_i_a_malloc(void * this, xwsz_t size, void ** membuf)
{
        struct xwmm_mempool_objcache * oc;
        xwer_t rc;
 
        oc = this;
        if (size > oc->objsize) {
                rc = -ESIZE;
                goto err_size;
        }
        rc = xwmm_mempool_objcache_alloc(oc, membuf);
        if (rc < 0) {
                goto err_alloc;
        }
        return XWOK;
 
err_alloc:
err_size:
        return rc;
}
 
static __xwos_code
xwer_t xwmm_mempool_objcache_i_a_free(void * this, void * mem)
{
        struct xwmm_mempool_objcache * oc;
        xwer_t rc;
 
        oc = this;
        rc = xwmm_mempool_objcache_free(oc, mem);
        return rc;
}