sophia-ruby 0.0.1

data/vendor/sophia/db/recover.h

@@ -0,0 +1,14 @@
+#ifndef SP_RECOVER_H_
+#define SP_RECOVER_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+int sp_recover(sp*);
+
+#endif

data/vendor/sophia/db/ref.h

@@ -0,0 +1,111 @@
+#ifndef SP_KEY_H_
+#define SP_KEY_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct spref spref;
+typedef struct sprefset sprefset;
+
+#define SPREFNONE 0
+#define SPREFD    1
+#define SPREFM    2
+
+struct spref {
+	uint8_t type;
+	union {
+		spvh *vh;
+		spv *v;
+	} v;
+} sppacked;
+
+struct sprefset {
+	spref *r;
+	int used;
+	int max;
+};
+
+static inline char*
+sp_refk(spref *r) {
+	switch (r->type) {
+	case SPREFD: return r->v.vh->key;
+	case SPREFM: return r->v.v->key;
+	}
+	return NULL;
+}
+
+static inline size_t
+sp_refksize(spref *r) {
+	switch (r->type) {
+	case SPREFD: return r->v.vh->size;
+	case SPREFM: return r->v.v->size;
+	}
+	return 0;
+}
+
+static inline char*
+sp_refv(spref *r, char *p) {
+	switch (r->type) {
+	case SPREFD: return p + r->v.vh->voffset;
+	case SPREFM: return sp_vv(r->v.v);
+	}
+	return NULL;
+}
+
+static inline size_t
+sp_refvsize(spref *r) {
+	switch (r->type) {
+	case SPREFD: return r->v.vh->vsize;
+	case SPREFM: return sp_vvsize(r->v.v);
+	}
+	return 0;
+}
+
+static inline int
+sp_refisdel(spref *r) {
+	register int flags = 0;
+	switch (r->type) {
+	case SPREFM: flags = r->v.v->flags;
+		break;
+	case SPREFD: flags = r->v.vh->flags;
+		break;
+	}
+	return (flags & SPDEL? 1: 0);
+}
+
+static inline int
+sp_refsetinit(sprefset *s, spa *a, int count) {
+	s->r = sp_malloc(a, count * sizeof(spref));
+	if (spunlikely(s->r == NULL))
+		return -1;
+	s->used = 0;
+	s->max = count;
+	return 0;
+}
+
+static inline void
+sp_refsetfree(sprefset *s, spa *a) {
+	if (s->r) {
+		sp_free(a, s->r);
+		s->r = NULL;
+	}
+}
+
+static inline void
+sp_refsetadd(sprefset *s, spref *r) {
+	assert(s->used < s->max);
+	s->r[s->used] = *r;
+	s->used++;
+}
+
+static inline void
+sp_refsetreset(sprefset *s) {
+	s->used = 0;
+}
+
+#endif

data/vendor/sophia/db/rep.c

@@ -0,0 +1,128 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sp.h>
+
+void sp_repinit(sprep *r, spa *a) {
+	sp_listinit(&r->l);
+	r->a = a;
+	r->n = 0;
+	r->ndb = 0;
+	r->nxfer = 0;
+	r->epoch = 0;
+}
+
+void sp_repfree(sprep *r) {
+	splist *i, *n;
+	sp_listforeach_safe(&r->l, i, n) {
+		spepoch *e = spcast(i, spepoch, link);
+		sp_lockfree(&e->lock);
+		sp_free(r->a, e);
+	}
+}
+
+static inline int sp_repcmp(const void *p1, const void *p2) {
+	register const spepoch *a = *(spepoch**)p1;
+	register const spepoch *b = *(spepoch**)p2;
+	assert(a->epoch != b->epoch);
+	return (a->epoch > b->epoch)? 1: -1;
+}
+
+int sp_repprepare(sprep *r) {
+	spepoch **a = sp_malloc(r->a, sizeof(spepoch*) * r->n);
+	if (spunlikely(a == NULL))
+		return -1;
+	uint32_t epoch = 0;
+	int j = 0;
+	splist *i;
+	sp_listforeach(&r->l, i) {
+		a[j] = spcast(i, spepoch, link);
+		if (a[j]->epoch > epoch)
+			epoch = a[j]->epoch;
+		j++;
+	}
+	qsort(a, r->n, sizeof(spepoch*), sp_repcmp);
+	sp_listinit(&r->l);
+	j = 0;
+	while (j < r->n) {
+		sp_listinit(&a[j]->link);
+		sp_listappend(&r->l, &a[j]->link);
+		j++;
+	}
+	sp_free(r->a, a);
+	r->epoch = epoch;
+	return 0;
+}
+
+spepoch *sp_repmatch(sprep *r, uint32_t epoch) {
+	splist *i;
+	sp_listforeach(&r->l, i) {
+		spepoch *e = spcast(i, spepoch, link);
+		if (e->epoch == epoch)
+			return e;
+	}
+	return NULL;
+}
+
+spepoch *sp_repalloc(sprep *r, uint32_t epoch)
+{
+	spepoch *e = sp_malloc(r->a, sizeof(spepoch));
+	if (spunlikely(e == NULL))
+		return NULL;
+	memset(e, 0, sizeof(spepoch));
+	e->recover = SPRNONE;
+	e->epoch = epoch;
+	e->type = SPUNDEF;
+	e->nupdate = 0;
+	e->n = 0;
+	e->ngc = 0;
+	sp_lockinit(&e->lock);
+	sp_fileinit(&e->db, r->a);
+	sp_fileinit(&e->log, r->a);
+	sp_listinit(&e->pages);
+	sp_listinit(&e->link);
+	return e;
+}
+
+void sp_repattach(sprep *r, spepoch *e) {
+	sp_listappend(&r->l, &e->link);
+	r->n++;
+}
+
+void sp_repdetach(sprep *r, spepoch *e) {
+	sp_listunlink(&e->link);
+	r->n--;
+	sp_repset(r, e, SPUNDEF);
+}
+
+void sp_repset(sprep *r, spepoch *e, spepochtype t) {
+	switch (t) {
+	case SPUNDEF:
+		if (e->type == SPXFER)
+			r->nxfer--;
+		else
+		if (e->type == SPDB)
+			r->ndb--;
+		break;
+	case SPLIVE:	
+		assert(e->type == SPUNDEF);
+		break;
+	case SPXFER:	
+		assert(e->type == SPLIVE || e->type == SPUNDEF);
+		r->nxfer++;
+		break;
+	case SPDB:	
+		assert(e->type == SPXFER || e->type == SPUNDEF);
+		if (e->type == SPXFER)
+			r->nxfer--;
+		r->ndb++;
+		break;
+	}
+	e->type = t;
+}

data/vendor/sophia/db/rep.h

@@ -0,0 +1,120 @@
+#ifndef SP_REP_H_
+#define SP_REP_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct spepoch spepoch;
+typedef struct sprep sprep;
+
+enum spepochtype {
+	SPUNDEF,
+	SPLIVE,
+	SPXFER,
+	SPDB
+};
+
+typedef enum spepochtype spepochtype;
+
+#define SPRNONE 0
+#define SPRDB   1
+#define SPRDBI  2
+#define SPRLOG  4
+#define SPRLOGI 8
+
+struct spepoch {
+	uint32_t epoch;
+	uint32_t n;       /* count of pages */
+	uint32_t ngc;     /* count of gc pages */
+	uint32_t nupdate; /* count of updated keys */
+	spepochtype type; /* epoch life-cycle state */
+	uint32_t recover; /* recover status */
+	spfile log, db;
+	spspinlock lock;  /* db lock */
+	splist pages;     /* list of associated pages */
+	splist link;
+};
+
+struct sprep {
+	spa *a;
+	uint32_t epoch;
+	splist l;
+	int n;
+	int ndb;
+	int nxfer;
+};
+
+void sp_repinit(sprep*, spa*);
+void sp_repfree(sprep*);
+int sp_repprepare(sprep*);
+spepoch *sp_repmatch(sprep *r, uint32_t epoch);
+spepoch *sp_repalloc(sprep*, uint32_t);
+void sp_repattach(sprep*, spepoch*);
+void sp_repdetach(sprep*, spepoch*);
+void sp_repset(sprep*, spepoch*, spepochtype);
+
+static inline uint32_t
+sp_repepoch(sprep *r) {
+	return r->epoch;
+}
+
+static inline void
+sp_repepochincrement(sprep *r) {
+	r->epoch++;
+}
+
+static inline void
+sp_replockall(sprep *r) {
+	register splist *i;
+	sp_listforeach(&r->l, i) {
+		register spepoch *e = spcast(i, spepoch, link);
+		sp_lock(&e->lock);
+	}
+}
+
+static inline void
+sp_repunlockall(sprep *r) {
+	register splist *i;
+	sp_listforeach(&r->l, i) {
+		register spepoch *e = spcast(i, spepoch, link);
+		sp_unlock(&e->lock);
+	}
+}
+
+static inline spepoch*
+sp_replive(sprep *r) {
+	register spepoch *e = spcast(r->l.prev, spepoch, link);
+	assert(e->type == SPLIVE);
+	return e;
+}
+
+static inline spepoch*
+sp_repxfer(sprep *r) {
+	register splist *i;
+	sp_listforeach(&r->l, i) {
+		register spepoch *s = spcast(i, spepoch, link);
+		if (s->type == SPXFER)
+			return s;
+	}
+	return NULL;
+}
+
+static inline spepoch*
+sp_repgc(sprep *r, float factor) {
+	register splist *i;
+	sp_listforeach(&r->l, i) {
+		register spepoch *s = spcast(i, spepoch, link);
+		if (s->type != SPDB)
+			continue;
+		if (s->ngc > (s->n * factor))
+			return s;
+	}
+	return NULL;
+}
+
+#endif

data/vendor/sophia/db/sophia.h

@@ -0,0 +1,84 @@
+#ifndef SOPHIA_H_
+#define SOPHIA_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef void *(*spallocf)(void *ptr, size_t size, void *arg);
+typedef int (*spcmpf)(char *a, size_t asz, char *b, size_t bsz, void *arg);
+
+typedef enum {
+	/* env related */
+	SPDIR,     /* uint32_t, char* */
+	SPALLOC,   /* spallocf, void* */
+	SPCMP,     /* spcmpf, void* */
+	SPPAGE,    /* uint32_t */
+	SPGC,      /* int */
+	SPGCF,     /* double */
+	SPGROW,    /* uint32_t, double */
+	SPMERGE,   /* int */
+	SPMERGEWM, /* uint32_t */
+	/* db related */
+	SPMERGEFORCE,
+	/* unrelated */
+	SPVERSION  /* uint32_t*, uint32_t* */
+} spopt;
+
+enum {
+	SPO_RDONLY = 1,
+	SPO_RDWR   = 2,
+	SPO_CREAT  = 4,
+	SPO_SYNC   = 8
+};
+
+typedef enum {
+	SPGT,
+	SPGTE,
+	SPLT,
+	SPLTE
+} sporder;
+
+typedef struct {
+	uint32_t epoch;
+	uint64_t psn;
+	uint32_t repn;
+	uint32_t repndb;
+	uint32_t repnxfer;
+	uint32_t catn;
+	uint32_t indexn;
+	uint32_t indexpages;
+} spstat;
+
+void *sp_env(void);
+void *sp_open(void *env);
+int sp_ctl(void*, spopt, ...);
+int sp_destroy(void *ptr);
+int sp_set(void *db, const void *k, size_t ksize, const void *v, size_t vsize);
+int sp_delete(void *db, const void *k, size_t ksize);
+int sp_get(void *db, const void *k, size_t ksize, void **v, size_t *vsize);
+void *sp_cursor(void *db, sporder, const void *k, size_t ksize);
+int sp_fetch(void *cur);
+const char *sp_key(void *cur);
+size_t sp_keysize(void *cur);
+const char *sp_value(void *cur);
+size_t sp_valuesize(void *cur);
+char *sp_error(void *ptr);
+void sp_stat(void *ptr, spstat*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif