use librtti for worker/queue/resource

src/lib/wobj.c

@@ -3,3 +3,164 @@
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "mylock.h"
+#include "utils.h"
+#include "wobj.h"
+#include "xstring.h"
+
+typedef struct {
+    my_rwlock_t lock;
+    uint64_t    refcount;
+} worker_private_t;
+
+static size_t worker_datasize(va_list ap)
+{
+    size_t sz = sizeof(xce_worker_t);
+
+    return sz;
+}
+
+static int worker_init(meta_obj_t* obj, va_list ap)
+{
+    xce_worker_t*     dst  = RTTI_OBJ_TO_DATA(xce_worker_t, obj);
+    worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+    xce_worker_t*     src  = va_arg(ap, xce_worker_t*);
+
+    if ((src == NULL) || (src->attrs == NULL)) {
+        return -EINVAL;
+    }
+
+    dst->name  = makeString(src->name);
+    dst->attrs = (hostattrs_t*)calloc(1, sizeof(hostattrs_t));
+    if (dst->attrs == NULL) {
+        return -ENOMEM;
+    }
+
+    memcpy(dst->attrs, src->attrs, sizeof(*(dst->attrs)));
+
+    dst->attrs->hosttype  = makeString(src->attrs->hosttype);
+    dst->attrs->hostmodel = makeString(src->attrs->hostmodel);
+    dst->status           = src->status;
+
+    /* FIXME: */
+    zarray_init(&(dst->resvals), 64, NULL);
+
+    dst->dead_since   = src->dead_since;
+    dst->pending_ctrl = src->pending_ctrl;
+    MOVE_PTR(dst->dispatch_window_config, src->dispatch_window_config);
+    dst->nthresholds = src->nthresholds;
+    MOVE_PTR(dst->thresholds, src->thresholds);
+    dst->nresvals_to_sched = 0;
+    dst->resvals_to_sched  = NULL;
+
+    my_rwlock_init(&(priv->lock));
+    priv->refcount = 1;
+
+    return 1;
+}
+
+static void worker_destroy(meta_obj_t* obj)
+{
+    xce_worker_t*     w    = RTTI_OBJ_TO_DATA(xce_worker_t, obj);
+    worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+
+    dereference(w->name);
+
+    if (w->attrs != NULL) {
+        dereference(w->attrs->hosttype);
+        dereference(w->attrs->hostmodel);
+        FREEUP(w->attrs);
+    }
+
+    if (w->dispatch_window_config != NULL) { }
+
+    if (w->thresholds != NULL) { }
+
+    if (w->resvals_to_sched != NULL) { }
+
+    zarray_fini(&(w->resvals));
+
+    my_rwlock_fini(&(priv->lock));
+    memset(priv, 0x0, sizeof(*priv));
+
+    return;
+}
+
+static int worker_reference(meta_obj_t* obj)
+{
+    worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+
+    my_rwlock_wlock(&(priv->lock));
+    priv->refcount++;
+    my_rwlock_unlock(&(priv->lock));
+
+    return 1;
+}
+
+static void worker_dereference(meta_obj_t* obj)
+{
+    worker_private_t* priv  = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+    xce_worker_t*     w     = RTTI_OBJ_TO_DATA(xce_worker_t, obj);
+    uint64_t          count = 0;
+
+    my_rwlock_wlock(&(priv->lock));
+    priv->refcount--;
+    count = priv->refcount;
+    my_rwlock_unlock(&(priv->lock));
+
+    if (count == 0) {
+        destroy_(w, (obj_destroy_fn_t)worker_destroy);
+    }
+
+    return;
+}
+
+static int worker_lock(meta_obj_t* obj, uint64_t option)
+{
+    worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+    int               rc   = -EINVAL;
+
+    switch (option) {
+    case RTTI_LOCK_READ:
+        rc = my_rwlock_rlock(&(priv->lock));
+        break;
+    case RTTI_LOCK_WRITE:
+        rc = my_rwlock_wlock(&(priv->lock));
+        break;
+    default:
+        break;
+    }
+
+    return rc;
+}
+
+static void worker_unlock(meta_obj_t* obj)
+{
+    worker_private_t* priv = (worker_private_t*)RTTI_OBJ_TO_PRIV(obj);
+
+    my_rwlock_unlock(&(priv->lock));
+
+    return;
+}
+
+static typeinfo_t worker_type = {
+    .name        = "xce worker",
+    .privateSize = sizeof(worker_private_t),
+    .dataSize    = (datasize_fn_t)worker_datasize,
+    .init        = (obj_init_fn_t)worker_init,
+    .destroy     = NULL,
+    .interfaces
+    = { .reference
+        = &(intf_reference_t) { .reference = (reference_fn_t)worker_reference,
+                                .dereference
+                                = (dereference_fn_t)worker_dereference },
+       .lock = &(intf_lock_t) { .lock   = (lock_fn_t)worker_lock,
+                                 .unlock = (unlock_fn_t)worker_unlock } }
+};
+
+xce_worker_t* makeWorker(xce_worker_t* w)
+{
+    xce_worker_t* worker = makeInstance(&worker_type, w);
+    return worker;
+}