lei.chen/myxce
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

save works

Browse source
This commit is contained in:
Rongsong Shen 2026-03-03 16:49:26 +08:00
parent f4b1ba4cd7
commit acfbec875b
51 changed files with 622 additions and 1175 deletions
Download patch file Download diff file Expand all files Collapse all files

27
src/lib/configobj.c
View file

@ -48,9 +48,32 @@ static typeinfo_t xconfig_type = {
.destroy = (obj_destroy_fn_t)xconfig_destroy,
};
xce_config_t* makeConfig(xce_config_t* c)
xce_config_t* makeConfig(var configmgr, xce_config_t* c)
{
xce_config_t* c1 = makeInstance(&xconfig_type, c);
xce_config_t* c1 = NULL;
int rc = 0;
rc = key_find(configmgr, (void*)c->name, (void**)&c1);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (rc > 0) {
errno = EEXIST;
return NULL;
}
c1 = makeInstance(&xconfig_type, c);
if (c1 != NULL) {
rc = key_add(configmgr, (void*)c1->name, (void*)c1);
if (rc < 0) {
destroy(c1);
errno = -rc;
return NULL;
}
}
return c1;
}

1
src/lib/group.c
View file

@ -5,7 +5,6 @@
#include "group.h"
#include "kvmgr.h"
#include "objmgr.h"
#include "utils.h"
#include "xce/types.h"
#include "xstring.h"

26
src/lib/jobj.c
View file

@ -676,8 +676,30 @@ static typeinfo_t job_type = {
job_t* makeJob(var jobmgr, xce_job_t* j)
{
job_t* job = makeInstance(&job_type, j);
/* FIXME */
job_t* job = NULL;
int rc = 0;
rc = key_find(jobmgr, (void *)j->jobid, (void **)&job);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (rc > 0) {
errno = EEXIST;
return NULL;
}
job = makeInstance(&job_type, j);
if (job != NULL) {
rc = key_add(jobmgr, (void *)job->job.jobid, (void **)job);
if (rc < 0) {
destroy(job);
errno = -rc;
return NULL;
}
}
return job;
}

234
src/lib/kvmgr.c
View file

@ -7,237 +7,12 @@
#include "kv.h"
#include "kvmgr.h"
#include "mylock.h"
#include "objmgr.h"
#include "utils.h"
#include "xce/types.h"
#include "zarray.h"
#include "controller.capnp.h"
int kvmgr_init(kvmgr_t* mgr, hash_key_fn_t keyfn, int nslots, int delta,
zarray_item_killer_t killer)
{
ht_init(&(mgr->htab), nslots, keyfn);
zarray_init(&(mgr->data), delta, killer);
mylock_init(&(mgr->lock));
return 0;
}
void kvmgr_fini(kvmgr_t* mgr)
{
ht_fini(&(mgr->htab));
zarray_fini(&(mgr->data));
mylock_fini(&(mgr->lock));
}
static void* kvmgr_lock_(kvmgr_t* mgr, void* key, int op)
{
hent_t* e = NULL;
int32_t idx;
void* ptr;
e = ht_get(&(mgr->htab), key);
if (e == NULL) {
SET_ERROR(ENOENT);
return NULL;
}
idx = e->data;
if (idx < 0) {
SET_ERROR(ENOENT);
return NULL;
}
ptr = (void*)zarray_get(&(mgr->data), idx);
if (ptr == NULL) {
return NULL;
}
if (op == OBJREF_NOP) {
return ptr;
}
return obj_ref(ptr, op);
}
void* kvmgr_lock(kvmgr_t* mgr, void* key, int op)
{
void* ptr = NULL;
if (mgr == NULL) {
SET_ERROR(EINVAL);
return NULL;
}
if ((op != OBJREF_NOP) && (op != OBJREF_READ) && (op != OBJREF_UPDATE)) {
SET_ERROR(EINVAL);
return NULL;
}
mylock_lock(&(mgr->lock));
ptr = kvmgr_lock_(mgr, key, op);
mylock_unlock(&(mgr->lock));
return ptr;
}
void* kvmgr_lock_byid(kvmgr_t* mgr, int idx, int op)
{
void* ptr = NULL;
if (mgr == NULL) {
SET_ERROR(-EINVAL);
return NULL;
}
if ((idx < 0) || (idx >= mgr->data.caps)) {
SET_ERROR(-EINVAL);
return NULL;
}
if ((op != OBJREF_NOP) && (op != OBJREF_READ) && (op != OBJREF_UPDATE)) {
SET_ERROR(-EINVAL);
return NULL;
}
mylock_lock(&(mgr->lock));
ptr = (void*)zarray_get(&(mgr->data), idx);
mylock_unlock(&(mgr->lock));
if (ptr == NULL) {
return NULL;
}
if (op == OBJREF_NOP) {
return ptr;
}
return obj_ref(ptr, op);
}
static int32_t kvmgr_add_(kvmgr_t* mgr, void* key, void* p)
{
hent_t* e = NULL;
int idx;
e = ht_get(&(mgr->htab), key);
if (e != NULL) {
return -EEXIST;
}
idx = zarray_store(&(mgr->data), p);
if (idx < 0) {
return idx;
}
e = ht_add(&(mgr->htab), (void*)key);
if (e == NULL) {
zarray_del(&(mgr->data), idx);
return -errno;
}
e->data = idx;
return idx;
}
int32_t kvmgr_add(kvmgr_t* mgr, void* key, void* p)
{
int32_t idx;
if ((mgr == NULL) || (p == NULL)) {
return -EINVAL;
}
mylock_lock(&(mgr->lock));
idx = kvmgr_add_(mgr, key, p);
mylock_unlock(&(mgr->lock));
return idx;
}
static int32_t kvmgr_put_(kvmgr_t* mgr, void* key, int idx, void* p)
{
hent_t* e = NULL;
int idx1 = -1;
e = ht_get(&(mgr->htab), key);
if (e != NULL) {
idx1 = e->data;
if (idx1 >= 0) {
zarray_del(&(mgr->data), idx1);
}
} else {
e = ht_add(&(mgr->htab), (void*)key);
if (e == NULL) {
return -ENOMEM;
}
}
if (idx1 != idx) {
zarray_del(&(mgr->data), idx);
}
e->data = idx;
return zarray_put(&(mgr->data), idx, p);
}
int32_t kvmgr_put(kvmgr_t* mgr, void* key, int idx, void* p)
{
int rc;
if ((mgr == NULL) || (key == NULL) || (p == NULL) || (idx < 0)) {
return -EINVAL;
}
mylock_lock(&(mgr->lock));
rc = kvmgr_put_(mgr, key, idx, p);
mylock_unlock(&(mgr->lock));
return rc;
}
static void kvmgr_del_(kvmgr_t* mgr, void* key)
{
hent_t* e = NULL;
int idx;
e = ht_get(&(mgr->htab), key);
if (e == NULL) {
return;
}
idx = e->data;
if (idx < 0) {
return;
}
zarray_del(&(mgr->data), idx);
return;
}
void kvmgr_del(kvmgr_t* mgr, void* key)
{
if (mgr == NULL) {
return;
}
mylock_lock(&(mgr->lock));
kvmgr_del_(mgr, key);
mylock_unlock(&(mgr->lock));
}
int kvmgr_iter(kvmgr_t* mgr, zarray_iter_skip_fn_t skipfn, xlist_t* l,
void* arg)
{
int rc = 0;
mylock_lock(&(mgr->lock));
rc = zarray_iter_ex(&(mgr->data), skipfn, l, arg);
mylock_unlock(&(mgr->lock));
return rc;
}
typedef struct {
my_rwlock_t lock;
} xkvmgr_private_t;
@ -433,6 +208,13 @@ static int xkvmgr_iter_next(iterator_t* iter, void** data)
return iter_next(it, data);
}
static int xkvmgr_iter_reset(iterator_t* iter)
{
iterator_t* it = (iterator_t*)iter->data;
return iter_reset(it);
}
static void xkvmgr_iter_destroy(iterator_t* iter)
{
iterator_t* it = iter->data;
@ -546,7 +328,7 @@ typeinfo_t xkvmgr_type = {
.iter
= &(intf_iterator_t) { .make = (iter_make_fn_t)xkvmgr_make_iter,
.next = (iter_next_fn_t)xkvmgr_iter_next,
.reset = (iter_reset_fn_t)NULL,
.reset = (iter_reset_fn_t)xkvmgr_iter_reset,
.destroy
= (iter_destroy_fn_t)xkvmgr_iter_destroy } }
};

1
src/lib/meson.build
View file

@ -59,7 +59,6 @@ libxce_src = [ gen_srcs[0],
'kvmgr.c',
'mylock.c',
'netio.c',
'objmgr.c',
'request.c',
'threshold.c',
'utils.c',

306
src/lib/objmgr.c
View file

@ -1,306 +0,0 @@
#include <errno.h>
#include <stdlib.h>
#include "htab.h"
#include "objmgr.h"
#include "utils.h"
#include "zarray.h"
static objmgr_t* objmgr_default = NULL;
static void objtype_killer(objtype_t* typeval)
{
if (typeval == NULL) {
return;
}
if (typeval->fn_type_fini == NULL) {
return;
}
typeval->fn_type_fini(typeval);
}
int objmgr_init(objmgr_t* mgr)
{
if (mgr == NULL) {
return -EINVAL;
}
mylock_init(&(mgr->lock));
ht_init(&(mgr->names), 32, string_hash_key);
zarray_init(&(mgr->types), 32, (zarray_item_killer_t)objtype_killer);
return 0;
}
void objmgr_fini(objmgr_t* mgr)
{
if (mgr == NULL) {
return;
}
zarray_fini(&(mgr->types));
ht_fini(&(mgr->names));
mylock_fini(&(mgr->lock));
}
static int objmgr_register_internal(objmgr_t* mgr, objtype_t* type)
{
hent_t* e = NULL;
int idx;
e = ht_get(&(mgr->names), (void*)type->type);
if (e != NULL) {
return e->data;
}
e = ht_add(&(mgr->names), (void*)type->type);
if (e == NULL) {
return -ENOMEM;
}
idx = zarray_store(&(mgr->types), type);
if (idx < 0) {
ht_del(&(mgr->names), (void*)type->type);
return idx;
}
e->data = idx;
return idx;
}
int obj_init(objmgr_t* mgr, objtype_t* type, int32_t exdata, myobj_t* obj)
{
obj->type = type;
obj->nref = 1;
obj->nread = 0;
obj->nwrite = 0;
obj->exdata = exdata;
obj->magic = OBJ_MAGIC;
my_rwlock_init(&(obj->rwlock));
mylock_init(&(obj->lock));
return 1;
}
int objmgr_register(objmgr_t* mgr, objtype_t* type)
{
int rc = 0;
/* clang-format off */
if ((mgr == NULL) ||
(type == NULL) ||
(type->type == NULL) ||
(type->fn_create == NULL)) {
return -EINVAL;
}
/* clang-format on */
mylock_init(&(type->lock));
mylock_lock(&(mgr->lock));
rc = objmgr_register_internal(mgr, type);
mylock_unlock(&(mgr->lock));
return rc;
}
static void* create_obj_ex(objmgr_t* mgr, int type, va_list ap)
{
objtype_t* typeval = NULL;
void* obj;
if ((type < 0) || (type >= mgr->types.caps)) {
SET_ERROR(EINVAL);
return NULL;
}
typeval = (objtype_t*)zarray_get(&(mgr->types), type);
if (typeval == NULL) {
SET_ERROR(EINVAL);
return NULL;
}
obj = typeval->fn_create(mgr, typeval, ap);
return obj;
}
void* create_obj_by_typeid(objmgr_t* mgr, int type, ...)
{
va_list ap;
void* p = NULL;
va_start(ap, type);
p = create_obj_ex(mgr, type, ap);
va_end(ap);
return p;
}
void* create_obj_by_typename(objmgr_t* mgr, char* type, ...)
{
hent_t* e;
va_list ap;
void* p = NULL;
mylock_lock(&(mgr->lock));
e = ht_get(&(mgr->names), (void*)type);
mylock_unlock(&(mgr->lock));
if (e == NULL) {
SET_ERROR(EINVAL);
return NULL;
}
if (e->data < 0) {
SET_ERROR(EINVAL);
return NULL;
}
va_start(ap, type);
p = create_obj_ex(mgr, e->data, ap);
va_end(ap);
return p;
}
int typeid_of_name(objmgr_t* mgr, char* type)
{
hent_t* e;
int typeid;
mylock_lock(&(mgr->lock));
e = ht_get(&(mgr->names), (void*)type);
if (e == NULL) {
typeid = -ENOENT;
} else {
typeid = e->data;
}
mylock_unlock(&(mgr->lock));
return typeid;
}
void* obj_ref(void* obj, int op)
{
myobj_t* myobj;
if (obj == NULL) {
SET_ERROR(EINVAL);
return NULL;
}
myobj = TO_MYOBJ(obj);
if (myobj->magic != OBJ_MAGIC) {
SET_ERROR(EINVAL);
return NULL;
}
switch (op) {
case OBJREF_READ:
my_rwlock_rlock(&(myobj->rwlock));
break;
case OBJREF_UPDATE:
my_rwlock_wlock(&(myobj->rwlock));
break;
default:
break;
}
mylock_lock(&(myobj->lock));
switch (op) {
case OBJREF_READ:
myobj->nread++;
break;
case OBJREF_UPDATE:
myobj->nwrite++;
break;
default:
break;
}
myobj->nref++;
mylock_unlock(&(myobj->lock));
return obj;
}
void obj_deref(void* obj)
{
myobj_t* myobj;
int nc;
objtype_t* typeval;
int release_rwlock = 0;
if (obj == NULL) {
SET_ERROR(EINVAL);
return;
}
myobj = TO_MYOBJ(obj);
if (myobj->magic != OBJ_MAGIC) {
SET_ERROR(EINVAL);
return;
}
/* the object lock should be held */
mylock_lock(&(myobj->lock));
myobj->nref--;
nc = myobj->nref;
if ((myobj->nread > 0) || (myobj->nwrite > 0)) {
release_rwlock = 1;
if (myobj->nread > 0) {
myobj->nread--;
} else {
myobj->nwrite--;
}
}
mylock_unlock(&(myobj->lock));
if (release_rwlock) {
my_rwlock_unlock(&(myobj->rwlock));
}
if (nc > 0) {
return;
}
typeval = myobj->type;
if (typeval == NULL) {
return;
}
if (typeval->fn_fini != NULL) {
typeval->fn_fini(obj);
}
return;
}
objmgr_t* objmgr_get_default() { return objmgr_default; }
int objmgr_set_default(objmgr_t* mgr)
{
objmgr_default = mgr;
return 0;
}
myobj_t* obj_alloc(size_t size)
{
myobj_t* obj;
if (size <= 0) {
SET_ERROR(EINVAL);
return NULL;
}
obj = (myobj_t*)calloc(1, sizeof(*obj) + size);
return obj;
}

32
src/lib/qobj.c
View file

@ -105,7 +105,7 @@ static int queue_reference(meta_obj_t* obj)
static void queue_dereference(meta_obj_t* obj)
{
queue_private_t* priv = (queue_private_t*)RTTI_OBJ_TO_PRIV(obj);
xce_queue_t* w = RTTI_OBJ_TO_DATA(xce_queue_t, obj);
queue_t* w = RTTI_OBJ_TO_DATA(queue_t, obj);
uint64_t count = 0;
my_rwlock_wlock(&(priv->lock));
@ -163,9 +163,33 @@ static typeinfo_t queue_type = {
.unlock = (unlock_fn_t)queue_unlock } }
};
queue_t* makeQueue(var qmgr, xce_queue_t* w)
queue_t* makeQueue(var qmgr, xce_queue_t* q)
{
/* FIMXE: */
queue_t* queue = makeInstance(&queue_type, w);
queue_t* queue = NULL;
int rc = 0;
rc = key_find(qmgr, (void*)q->queue, (void**)&queue);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (rc > 0) {
errno = EEXIST;
return NULL;
}
queue = makeInstance(&queue_type, q);
if (queue != NULL) {
reference(queue);
rc = key_add(qmgr, (void*)q->queue, (void*)queue);
if (rc < 0) {
destroy(queue);
errno = -rc;
return NULL;
}
}
return queue;
}

29
src/lib/resobj.c
View file

@ -112,8 +112,33 @@ static typeinfo_t resobj_type
.reference = (reference_fn_t)resobj_reference,
.dereference = (dereference_fn_t)resobj_dereference } } };
xce_resource_t* makeResource(xce_resource_t* w)
xce_resource_t* makeResource(var resmgr, xce_resource_t* r)
{
xce_resource_t* resobj = makeInstance(&resobj_type, w);
xce_resource_t* resobj = NULL;
int rc;
rc = key_find(resmgr, (void*)r->name, (void**)&resobj);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (rc > 0) {
errno = EEXIST;
return NULL;
}
resobj = makeInstance(&resobj_type, r);
if (resobj != NULL) {
reference(resobj);
rc = key_add(resmgr, (void*)resobj->name, (void*)resobj);
if (rc < 0) {
destroy(resobj);
errno = -rc;
return NULL;
}
}
return resobj;
}

1
src/lib/resreq.c
View file

@ -4,7 +4,6 @@
#include <string.h>
#include "kvmgr.h"
#include "objmgr.h"
#include "resreq.h"
#include "rusage.h"
#include "section.h"

14
src/lib/testsuite/test_qobj.c
View file

@ -1,15 +1,15 @@
#include <rtti.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <rtti.h>
#include <unity/unity.h>
#include "kvmgr.h"
#include "qobj.h"
#include "utils.h"
#include "xstring.h"
#include "kvmgr.h"
static void test_queue_create(void)
{
@ -17,10 +17,14 @@ static void test_queue_create(void)
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.nslots = 32,
.delta = 32,
.datakiller = destroy };
.datakiller = dereference };
var qmgr;
xce_queue_t q1 = { 0 };
xce_queue_t q1 = { .queue = "xce",
.resreq = "type == any",
.pre_exec = NULL,
.post_exec = NULL,
.autopscaler = NULL };
queue_t* q = NULL;
rc = xstring_table_init(32);
@ -33,7 +37,7 @@ static void test_queue_create(void)
TEST_ASSERT_TRUE(q != NULL);
destroy(q);
dereference(q);
destroy(qmgr);
xstring_table_fini();

3
src/lib/testsuite/test_wobj.c
View file

@ -16,7 +16,7 @@ static void test_worker_create(void)
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
.nslots = 32,
.delta = 32,
.datakiller = destroy };
.datakiller = dereference };
var workermgr;
hostattrs_t attrs1 = { .hosttype = "LINUX64",
.hostmodel = "linux-gnu-x86_64",
@ -48,7 +48,6 @@ static void test_worker_create(void)
&& (w->host.attrs->maxcpus == attrs1.maxcpus));
dereference(w);
destroy(workermgr);
xstring_table_fini();

1
src/lib/testsuite/test_xstring.c
View file

@ -3,7 +3,6 @@
#include <string.h>
#include <unity/unity.h>
#include "objmgr.h"
#include "utils.h"
#include "xstring.h"

28
src/lib/wobj.c
View file

@ -161,7 +161,31 @@ static typeinfo_t worker_type = {
worker_t* makeWorker(var workermgr, xce_worker_t* w)
{
worker_t* worker = makeInstance(&worker_type, w);
/* fIXME */
worker_t* worker = NULL;
int rc = 0;
rc = key_find(workermgr, (void*)w->name, (void**)&worker);
if ((rc < 0) && (rc != -ENOENT)) {
errno = -rc;
return NULL;
}
if (rc > 0) {
errno = EEXIST;
return NULL;
}
worker = makeInstance(&worker_type, w);
if (worker != NULL) {
reference(worker);
rc = key_add(workermgr, (void*)worker->host.name, (void*)worker);
if (rc < 0) {
destroy(worker);
errno = -rc;
return NULL;
}
}
return worker;
}

8
src/lib/xcelimit.c
View file

@ -8,7 +8,6 @@
#include "group.h"
#include "kvmgr.h"
#include "objmgr.h"
#include "utils.h"
#include "xce/types.h"
#include "xcelimit.h"
@ -58,7 +57,7 @@ int fmt_consumer(char* buf, int len, xce_consumer_t* c)
return -EINVAL;
}
int build_consumer(xce_consumer_t** pconsumer, groupmgr_t* mgr,
int build_consumer(xce_consumer_t** pconsumer, var mgr,
xce_consumer_type_t type, int per_consumer,
xce_group_config_t* g_config, char* default_name_prefix)
{
@ -193,9 +192,8 @@ void kill_limit(xce_limit_t* limit)
FREEUP(limit);
}
int build_limit(xce_limit_t** plimit, groupmgr_t* ugmgr, groupmgr_t* qgmgr,
groupmgr_t* hgmgr, groupmgr_t* pgmgr,
xce_limit_config_t* config)
int build_limit(xce_limit_t** plimit, var ugmgr, var qgmgr, var hgmgr,
var pgmgr, xce_limit_config_t* config)
{
xce_limit_t* limit = NULL;
int rc = 0;