sophia-ruby 0.0.1

data/vendor/sophia/db/file.h

@@ -0,0 +1,106 @@
+#ifndef SP_FILE_H_
+#define SP_FILE_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct spfile spfile;
+
+struct spfile {
+	spa *a;
+	int creat;
+	uint64_t used;
+	uint64_t size;
+	uint64_t svp;
+	char *file;
+	int fd;
+	char *map;
+	struct iovec iov[8];
+	int iovc;
+};
+
+int sp_fileexists(char*);
+int sp_filerm(char*);
+
+static inline void
+sp_fileinit(spfile *f, spa *a) {
+	memset(f, 0, sizeof(*f));
+	f->a = a;
+	f->fd = -1;
+}
+
+static inline void
+sp_filesvp(spfile *f) {
+	f->svp = f->used;
+}
+
+int sp_mapopen(spfile*, char*);
+int sp_mapnew(spfile*, char*, uint64_t);
+int sp_mapclose(spfile*);
+int sp_mapcomplete(spfile*);
+int sp_mapunmap(spfile*);
+int sp_mapunlink(spfile*);
+int sp_mapensure(spfile*, uint64_t, float);
+
+static inline int
+sp_mapepoch(spfile *f, char *dir, uint32_t epoch, char *ext) {
+	char path[1024];
+	snprintf(path, sizeof(path), "%s/%"PRIu32".%s", dir, epoch, ext);
+	return sp_mapopen(f, path);
+}
+
+static inline int
+sp_mapepochnew(spfile *f, uint64_t size,
+               char *dir, uint32_t epoch, char *ext) {
+	char path[1024];
+	snprintf(path, sizeof(path), "%s/%"PRIu32".%s.incomplete", dir, epoch, ext);
+	return sp_mapnew(f, path, size);
+}
+
+static inline void
+sp_mapuse(spfile *f, size_t size) {
+	f->used += size;
+	assert(f->used <= f->size);
+}
+
+static inline void
+sp_maprlb(spfile *f) {
+	f->used = f->svp;
+}
+
+static inline int
+sp_mapinbound(spfile *f, size_t off) {
+	return off <= f->size;
+}
+
+int sp_lognew(spfile*, char*, uint32_t);
+int sp_logcontinue(spfile*, char*, uint32_t);
+int sp_logclose(spfile*);
+int sp_logcomplete(spfile*);
+int sp_logcompleteforce(spfile*);
+int sp_logunlink(spfile*);
+int sp_logflush(spfile*);
+int sp_logrlb(spfile*);
+int sp_logeof(spfile*);
+
+static inline void
+sp_logadd(spfile *f, const void *buf, int size) {
+	assert(f->iovc < 8);
+	f->iov[f->iovc].iov_base = (void*)buf;
+	f->iov[f->iovc].iov_len = size;
+	f->iovc++;
+}
+
+static inline int
+sp_epochrm(char *dir, uint32_t epoch, char *ext) {
+	char path[1024];
+	snprintf(path, sizeof(path), "%s/%"PRIu32".%s", dir, epoch, ext);
+	return sp_filerm(path);
+}
+
+#endif

data/vendor/sophia/db/gc.c

@@ -0,0 +1,71 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sp.h>
+
+int sp_gc(sp *s, spepoch *x)
+{
+	/*
+	 * copy all yet active pages from a epoch's
+	 * databases picked for the garbage
+	 * collecting.
+	*/
+	for (;;)
+	{
+		sp_lock(&s->lockr);
+		spepoch *g = sp_repgc(&s->rep, s->e->gcfactor);
+		sp_unlock(&s->lockr);
+		if (g == NULL)
+			break;
+
+		int rc;
+		splist *i, *n;
+		sp_listforeach_safe(&g->pages, i, n) {
+			sppage *p = spcast(i, sppage, link);
+
+			/* map origin page and copy to db file */
+			sppageh *h = (sppageh*)(g->db.map + p->offset);
+			sp_lock(&x->lock);
+			rc = sp_mapensure(&x->db, sizeof(sppageh) + h->size, s->e->dbgrow);
+			if (spunlikely(rc == -1)) {
+				sp_unlock(&x->lock);
+				return sp_e(s, SPEIO, "failed to remap db file", x->epoch);
+			}
+			sp_unlock(&x->lock);
+			memcpy(x->db.map + x->db.used, h, sizeof(sppageh) + h->size);
+
+			/* update page location */
+			sp_lock(&s->locks);
+			sp_listunlink(&p->link);
+			sp_listappend(&x->pages, &p->link);
+			p->epoch = x;
+			p->offset = x->db.used;
+			sp_unlock(&s->locks);
+
+			/* advance file pointer */
+			sp_mapuse(&x->db, sizeof(sppageh) + h->size);
+		}
+
+		/*
+		 * remove old files and unlink the epoch
+		 * from the repository.
+		*/
+		rc = sp_mapunlink(&g->db);
+		if (spunlikely(rc == -1))
+			return sp_e(s, SPEIO, "failed to unlink db file", g->epoch);
+		rc = sp_mapclose(&g->db);
+		if (spunlikely(rc == -1))
+			return sp_e(s, SPEIO, "failed to close db file", g->epoch);
+		sp_lock(&s->lockr);
+		sp_repdetach(&s->rep, g);
+		sp_free(&s->a, g);
+		sp_unlock(&s->lockr);
+	}
+	return 0;
+}

data/vendor/sophia/db/gc.h

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

data/vendor/sophia/db/i.c

@@ -0,0 +1,368 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sp.h>
+
+static inline int sp_iensure(spi *i) {
+	if (splikely((i->icount + 1) < i->itop))
+		return 0;
+	i->itop *= 2;
+	i->i = sp_realloc(i->a, i->i, i->itop * sizeof(spipage*));
+	if (spunlikely(i->i == NULL))
+		return -1;
+	return 0;
+}
+
+static inline int
+sp_ipagesize(spi *i) {
+	return sizeof(spipage) + sizeof(spv*) * i->pagesize;
+}
+
+static inline spipage*
+sp_ipagealloc(spi *i) {
+	spipage *p = sp_malloc(i->a, sp_ipagesize(i));
+	if (spunlikely(p == NULL))
+		return NULL;
+	p->count = 0;
+	return p;
+}
+
+int sp_iinit(spi *i, spa *a, int pagesize, spcmpf cmp, void *cmparg)
+{
+	i->a = a;
+	i->cmp = cmp;
+	i->cmparg = cmparg;
+	i->count = 0;
+	i->pagesize = pagesize;
+	/* start from 4 pages vector */
+	i->itop = 2;
+	i->icount = 1;
+	i->i = NULL;
+	int rc = sp_iensure(i);
+	if (spunlikely(rc == -1))
+		return -1;
+	/* allocate first page */
+	i->i[0] = sp_ipagealloc(i);
+	if (spunlikely(i->i[0] == NULL)) {
+		sp_free(i->a, i->i);
+		i->i = NULL;
+		return -1;
+	}
+	return 0;
+}
+
+void sp_ifree(spi *i)
+{
+	uint32_t p = 0;
+	while (p < i->icount) {
+		uint32_t k = 0;
+		while (k < i->i[p]->count) {
+			sp_free(i->a, i->i[p]->i[k]);
+			k++;
+		}
+		sp_free(i->a, i->i[p]);
+		p++;
+	}
+	sp_free(i->a, i->i);
+	i->i = NULL;
+}
+
+int sp_itruncate(spi *i)
+{
+	sp_ifree(i);
+	return sp_iinit(i, i->a, i->pagesize, i->cmp, i->cmparg);
+}
+
+static inline void*
+sp_iminof(spi *i, spipage *p, char *rkey, int size, uint32_t *idx)
+{
+	register int min = 0;
+	register int max = p->count - 1;
+	while (max >= min) {
+		register int mid = min + ((max - min) >> 1);
+		register int rc =
+			i->cmp(p->i[mid]->key,
+			       p->i[mid]->size, rkey, size, i->cmparg);
+		switch (rc) {
+		case -1: min = mid + 1;
+			continue;
+		case  1: max = mid - 1;
+			continue;
+		default: *idx = mid;
+			return p->i[mid];
+		}
+	}
+	*idx = min;
+	return NULL;
+}
+
+static inline void*
+sp_imaxof(spi *i, spipage *p, char *rkey, int size, uint32_t *idx)
+{
+	register int min = 0;
+	register int max = p->count - 1;
+	while (max >= min) {
+		register int mid = min + ((max - min) >> 1);
+		register int rc =
+			i->cmp(p->i[mid]->key,
+			       p->i[mid]->size,
+				   rkey, size, i->cmparg);
+		switch (rc) {
+		case -1: min = mid + 1;
+			continue;
+		case  1: max = mid - 1;
+			continue;
+		default: *idx = mid;
+			return p->i[mid];
+		}
+	}
+	*idx = max;
+	return NULL;
+}
+
+static inline int
+sp_ipagecmp(spi *i, spipage *p, char *rkey, int size)
+{
+	if (spunlikely(p->count == 0))
+		return 0;
+	register int l =
+		i->cmp(p->i[0]->key, p->i[0]->size, rkey, size, i->cmparg);
+	register int r =
+		i->cmp(p->i[p->count-1]->key, p->i[p->count-1]->size,
+	           rkey, size, i->cmparg);
+	/* inside page range */
+	if (l <= 0 && r >= 0)
+		return 0;
+	/* page min < key */
+	if (l == -1)
+		return -1;
+	/* page max > key */
+	assert(r == 1);
+	return 1;
+}
+
+static inline spipage*
+sp_ipageof(spi *i, char *rkey, int size, uint32_t *idx)
+{
+	register int min = 0;
+	register int max = i->icount - 1;
+	while (max >= min) {
+		register int mid = min + ((max - min) >> 1);
+		switch (sp_ipagecmp(i, i->i[mid], rkey, size)) {
+		case -1: min = mid + 1;
+			continue;
+		case  1: max = mid - 1;
+			continue;
+		default:
+			*idx = mid;
+			return i->i[mid];
+		}
+	}
+	*idx = min;
+	return NULL;
+}
+
+int sp_isetorget(spi *i, spv *v, spii *old)
+{
+	/* 1. do binary search on the vector and find usable
+	 * page for a key */
+	spipage *p = i->i[0];
+	uint32_t a = 0;
+	if (splikely(i->icount > 1)) {
+		p = sp_ipageof(i, v->key, v->size, &a);
+		if (spunlikely(p == NULL)) {
+			if (a >= i->icount)
+				a = i->icount-1;
+			p = i->i[a];
+			assert(a < i->icount);
+		}
+		assert(p != NULL);
+	}
+
+	/* 2. if page is full, split it and insert new one:
+	 * copy second half of the keys from first page to second */
+	/* 2.1. insert page to vector, by moving pointers forward */
+	if (spunlikely(p->count == i->pagesize)) {
+		int rc = sp_iensure(i);
+		if (spunlikely(rc == -1))
+			return -1;
+		/* split page */
+		spipage *n = sp_ipagealloc(i);
+		if (spunlikely(n == NULL))
+			return -1;
+		int half = p->count >> 1;
+		memcpy(&n->i[0], &p->i[half], sizeof(void*) * (half));
+		n->count = half;
+		p->count = half;
+		/* split page i and insert new page */
+		memmove(&i->i[a + 1], &i->i[a], sizeof(spipage*) * (i->icount - a));
+		i->i[a] = p;
+		i->i[a+1] = n;
+		i->icount++;
+		/* choose which part to use */
+		if (sp_ipagecmp(i, n, v->key, v->size) <= 0) {
+			p = n;
+			a++;
+		}
+	}
+
+	/* 3. if page is not full, do nothing */
+	/* 4. do binary search on a page and match room, move
+	 * pointers forward */
+	/* 5. insert key, increment counters */
+	assert(p->count < i->pagesize);
+
+	uint32_t j;
+	void *o = sp_iminof(i, p, v->key, v->size, &j);
+	if (spunlikely(o)) {
+		old->i = i;
+		old->p = a;
+		old->n = j;
+		assert(sp_ival(old) == o);
+		return 1;
+	}
+	if (j >= p->count) {
+		p->i[p->count] = v;
+	} else {
+		memmove(&p->i[j + 1], &p->i[j], sizeof(spv*) * (p->count - j));
+		p->i[j] = v;
+	}
+	i->count++;
+	p->count++;
+	return 0;
+}
+
+int sp_idelraw(spi *i, char *rkey, int size, spv **old)
+{
+	spipage *p = i->i[0];
+	uint32_t a = 0;
+	if (splikely(i->icount > 1))
+		p = sp_ipageof(i, rkey, size, &a);
+	if (spunlikely(p == NULL))
+		return 0;
+	uint32_t j;
+	*old = sp_iminof(i, p, rkey, size, &j);
+	if (spunlikely(*old == NULL))
+		return 0;
+	if (splikely(j != (uint32_t)(p->count-1)))
+		memmove(&p->i[j], &p->i[j + 1], sizeof(spv*) * (p->count - j - 1));
+	p->count--;
+	i->count--;
+	if (splikely(p->count > 0))
+		return 1;
+	/* do not touch last page */
+	if (spunlikely(i->icount == 1))
+		return 1;
+	/* remove empty page */
+	sp_free(i->a, i->i[a]);
+	if (splikely(a != (i->icount - 1)))
+		memmove(&i->i[a], &i->i[a + 1], sizeof(spipage*) * (i->icount - a - 1));
+	i->icount--;
+	return 1;
+}
+
+spv *sp_igetraw(spi *i, char *rkey, int size)
+{
+	spipage *p = i->i[0];
+	uint32_t a = 0;
+	if (splikely(i->icount > 1))
+		p = sp_ipageof(i, rkey, size, &a);
+	if (p == NULL)
+		return NULL;
+	uint32_t j;
+	return sp_iminof(i, p, rkey, size, &j);
+}
+
+static inline int
+sp_iworldcmp(spi *i, char *rkey, int size)
+{
+	register spipage *last = i->i[i->icount-1];
+	register int l =
+		i->cmp(i->i[0]->i[0]->key,
+		       i->i[0]->i[0]->size, rkey, size, i->cmparg);
+	register int r =
+		i->cmp(last->i[last->count-1]->key,
+		       last->i[last->count-1]->size,
+	           rkey, size, i->cmparg);
+	/* inside index range */
+	if (l <= 0 && r >= 0)
+		return 0;
+	/* index min < key */
+	if (l == -1)
+		return -1;
+	/* index max > key */
+	assert(r == 1);
+	return 1;
+}
+
+int sp_ilte(spi *i, spii *ii, char *k, int size)
+{
+	if (spunlikely(i->count == 0)) {
+		sp_iinv(i, ii);
+		return 0;
+	}
+	spipage *p = i->i[0];
+	uint32_t a = 0;
+	if (splikely(i->icount > 1))
+		p = sp_ipageof(i, k, size, &a);
+	if (p == NULL) {
+		switch (sp_iworldcmp(i, k, size)) {
+		case -1:
+			sp_iinv(i, ii);
+			break;
+		case  1:
+			ii->i = i;
+			ii->p = i->icount - 1;
+			ii->n = i->i[i->icount - 1]->count - 1;
+			break;
+		case  0:
+			assert(0);
+		}
+		return 0;
+	}
+	uint32_t j;
+	int eq = sp_iminof(i, p, k, size, &j) != NULL;
+	ii->i = i;
+	ii->p = a;
+	ii->n = j;
+	return eq;
+}
+
+int sp_igte(spi *i, spii *ii, char *k, int size)
+{
+	if (spunlikely(i->count == 0)) {
+		sp_iinv(i, ii);
+		return 0;
+	}
+	spipage *p = i->i[0];
+	uint32_t a = 0;
+	if (splikely(i->icount > 1))
+		p = sp_ipageof(i, k, size, &a);
+	if (p == NULL) {
+		switch (sp_iworldcmp(i, k, size)) {
+		case -1:
+			ii->i = i;
+			ii->p = i->icount - 1;
+			ii->n = i->i[i->icount - 1]->count - 1;
+			break;
+		case  1:
+			sp_iinv(i, ii);
+			break;
+		case  0:
+			assert(0);
+		}
+		return 0;
+	}
+	uint32_t j;
+	int eq = sp_imaxof(i, p, k, size, &j) != NULL;
+	ii->i = i;
+	ii->p = a;
+	ii->n = j;
+	return eq;
+}