object.c

浏览该文件的文档.

 
#include <xwos/standard.h>
#include <xwos/lib/object.h>
#include <xwos/osal/irq.h>
#include <xwos/osal/skd.h>
#include <xwos/osal/lock/spinlock.h>
 
static __xwlib_code
xwsq_t xwos_objtik_get(void);
 
static __xwlib_code
xwer_t xwos_object_release_refaop_tst(const void * ov, void * arg);
 
static __xwlib_code
void xwos_object_release_refaop_op(void * nv, const void * ov, void * arg);
 
#define XWOS_OBJTIK_CHUNK        ((xwsq_t)1 << 20U) /* 1M */
#define XWOS_OBJTIK_CHUNK_MSK    (XWOS_OBJTIK_CHUNK - 1U)
 
static __xwlib_data
struct xwos_splk xwos_objtik_lock = XWOS_SPLK_INITIALIZER;
 
static __xwlib_data
atomic_xwsq_t xwos_objtik_dispatcher = (CPUCFG_CPU_NUM * XWOS_OBJTIK_CHUNK);
 
static __xwlib_data
atomic_xwsq_t xwos_objtik[CPUCFG_CPU_NUM] __xwcc_alignl1cache = {0};
 
__xwlib_code
void xwos_objtik_init(void)
{
        xwsq_t i;
 
        xwos_objtik_dispatcher = (CPUCFG_CPU_NUM * XWOS_OBJTIK_CHUNK);
        for (i = 0; i < CPUCFG_CPU_NUM; i++) {
                xwos_objtik[i] = (i * XWOS_OBJTIK_CHUNK);
        }
}
 
static __xwlib_code
xwsq_t xwos_objtik_get(void)
{
        xwid_t cpu;
        atomic_xwsq_t * objtik;
        xwsq_t curr;
        xwsq_t max;
        xwsq_t ov;
        xwer_t rc;
 
        cpu = xwos_skd_get_cpuid_lc();
        objtik = &xwos_objtik[cpu];
        do {
                curr = xwaop_load(xwsq_t, objtik, xwaop_mo_relaxed);
                max = (curr & (~XWOS_OBJTIK_CHUNK_MSK)) + XWOS_OBJTIK_CHUNK_MSK;
                rc = xwaop_tlt_then_add(xwsq_t, objtik, max, 1, NULL, &ov);
                if (rc < 0) {
                        xwreg_t cpuirq;
                        xwsq_t chunk;
 
                        xwos_splk_lock_cpuirqsv(&xwos_objtik_lock, &cpuirq);
                        curr = xwaop_load(xwsq_t, objtik, xwaop_mo_relaxed);
                        if (curr == max) {
                                ov = curr;
                                xwaop_add(xwsq_t, &xwos_objtik_dispatcher,
                                          XWOS_OBJTIK_CHUNK, NULL, &chunk);
                                xwaop_store(xwsq_t, objtik, xwaop_mo_relaxed, chunk);
                                xwos_splk_unlock_cpuirqrs(&xwos_objtik_lock, cpuirq);
                                break;
                        } else {
                                xwos_splk_unlock_cpuirqrs(&xwos_objtik_lock, cpuirq);
                        }
                }
        } while (curr > max);
        return ov;
}
 
__xwlib_code
void xwos_object_construct(struct xwos_object * obj)
{
        obj->refcnt = 0;
        obj->gcfunc = NULL;
        obj->tik = 0;
}
 
__xwlib_code
void xwos_object_destruct(struct xwos_object * obj)
{
        obj->gcfunc = NULL;
        obj->tik = 0;
        obj->magic = 0;
}
 
__xwlib_code
xwer_t xwos_object_activate(struct xwos_object * obj, xwobj_gc_f gcfunc)
{
        xwer_t rc;
 
        rc = xwaop_teq_then_add(xwsq_t, &obj->refcnt, 0, 1, NULL, NULL);
        if (XWOK == rc) {
                obj->tik = xwos_objtik_get();
                obj->magic = XWOS_OBJ_MAGIC;
                obj->gcfunc = gcfunc;
        } else {
                rc = -EOBJACTIVE;
        }
        return rc;
}
 
__xwlib_code
void xwos_object_setgc(struct xwos_object * obj, xwobj_gc_f gcfunc)
{
        if (XWOS_OBJ_MAGIC == obj->magic) {
                obj->gcfunc = gcfunc;
        }
}
 
static __xwlib_code
xwer_t xwos_object_acquire_refaop_tst(const void * ov, void * arg)
{
        const xwsq_t * o;
        xwobj_d * objd;
        xwer_t rc;
 
        o = (const xwsq_t *)ov;
        objd = arg;
        if ((XWOS_OBJ_MAGIC != objd->obj->magic) ||
            (objd->tik != objd->obj->tik)) {
                rc = -EACCES;
        } else if (*o < 1) {
                rc = -EOBJDEAD;
        } else {
                rc = XWOK;
        }
        return rc;
}
 
static __xwlib_code
void xwos_object_acquire_refaop_op(void * nv, const void * ov, void * arg)
{
        xwsq_t * n;
        const xwsq_t * o;
 
        XWOS_UNUSED(arg);
        n = (xwsq_t *)nv;
        o = (const xwsq_t *)ov;
        *n = *o + 1;
}
 
__xwlib_code
xwer_t xwos_object_acquire(struct xwos_object * obj, xwsq_t tik)
{
        xwobj_d objd = {obj, tik};
        xwer_t rc;
 
        if ((NULL == obj) || ((xwsq_t)0 == tik)) {
                rc = -ENILOBJD;
        } else {
                rc = xwaop_tst_then_op(xwsq_t, &obj->refcnt,
                                       xwos_object_acquire_refaop_tst, &objd,
                                       xwos_object_acquire_refaop_op, &objd,
                                       NULL, NULL);
        }
        return rc;
}
 
static __xwlib_code
xwer_t xwos_object_release_refaop_tst(const void * ov, void * arg)
{
        const xwsq_t * o;
        xwobj_d * objd;
        xwer_t rc;
 
        o = (const xwsq_t *)ov;
        objd = arg;
        if ((XWOS_OBJ_MAGIC != objd->obj->magic) ||
            (objd->tik != objd->obj->tik)) {
                rc = -EACCES;
        } else if (*o < 1) {
                rc = -EOBJDEAD;
        } else {
                rc = XWOK;
        }
        return rc;
}
 
static __xwlib_code
void xwos_object_release_refaop_op(void * nv, const void * ov, void * arg)
{
        xwsq_t * n;
        const xwsq_t * o;
 
        XWOS_UNUSED(arg);
        n = (xwsq_t *)nv;
        o = (const xwsq_t *)ov;
        *n = *o - 1;
}
 
__xwlib_code
xwer_t xwos_object_release(struct xwos_object * obj, xwsq_t tik)
{
        xwobj_d objd = {obj, tik};
        xwsq_t nv;
        xwer_t rc;
 
        if ((NULL == obj) || ((xwsq_t)0 == tik)) {
                rc = -ENILOBJD;
        } else {
                rc = xwaop_tst_then_op(xwsq_t, &obj->refcnt,
                                       xwos_object_release_refaop_tst, &objd,
                                       xwos_object_release_refaop_op, &objd,
                                       &nv, NULL);
                if (XWOK == rc) {
                        if ((xwsq_t)0 == nv) {
                                if (NULL != obj->gcfunc) {
                                        rc = obj->gcfunc(obj);
                                }
                        }
                }
        }
        return rc;
}
 
__xwlib_code
xwer_t xwos_object_grab(struct xwos_object * obj)
{
        xwer_t rc;
 
        rc = xwaop_tge_then_add(xwsq_t, &obj->refcnt, 1, 1, NULL, NULL);
        if (rc < 0) {
                rc = -EOBJDEAD;
        }
        return rc;
}
 
__xwlib_code
xwer_t xwos_object_put(struct xwos_object * obj)
{
        xwer_t rc;
        xwsq_t nv;
 
        rc = xwaop_tgt_then_sub(xwsq_t, &obj->refcnt,
                                0, 1,
                                &nv, NULL);
        if (XWOK == rc) {
                if ((xwsq_t)0 == nv) {
                        if (NULL != obj->gcfunc) {
                                rc = obj->gcfunc(obj);
                        }
                }
        } else {
                rc = -EOBJDEAD;
        }
        return rc;
}
 
__xwlib_code
xwer_t xwos_object_rawput(struct xwos_object * obj)
{
        xwer_t rc;
 
        rc = xwaop_tgt_then_sub(xwsq_t, &obj->refcnt,
                                0, 1,
                                NULL, NULL);
        if (rc < 0) {
                rc = -EOBJDEAD;
        }
        return rc;
}
 
__xwlib_code
xwsq_t xwos_object_get_refcnt(struct xwos_object * obj)
{
        return xwaop_load(xwsq_t, &obj->refcnt, xwaop_mo_relaxed);
}