sophia-ruby 0.0.1

data/vendor/sophia/COPYRIGHT

@@ -0,0 +1,29 @@
+
+Copyright (C) 2013 Dmitry Simonenko (pmwkaa@gmail.com)
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+1. Redistributions of source code must retain the above
+   copyright notice, this list of conditions and the
+   following disclaimer.
+
+2. Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials
+   provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY AUTHORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/sophia/README

@@ -0,0 +1,5 @@
+
+sophia - is a modern embeddable key-value database
+designed for a high load.
+
+http://sphia.org

data/vendor/sophia/db/a.h

@@ -0,0 +1,58 @@
+#ifndef SP_A_H_
+#define SP_A_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct spa spa;
+
+struct spa {
+	spallocf alloc;
+	void *arg;
+};
+
+static inline void
+sp_allocinit(spa *a, spallocf f, void *arg) {
+	a->alloc = f;
+	a->arg = arg;
+}
+
+static inline void*
+sp_allocstd(void *ptr, size_t size, void *arg spunused) {
+	if (splikely(size > 0)) {
+		if (ptr != NULL)
+			return realloc(ptr, size);
+		return malloc(size);
+	}
+	assert(ptr != NULL);
+	free(ptr);
+	return NULL;
+}
+
+static inline void *sp_realloc(spa *a, void *ptr, size_t size) {
+	return a->alloc(ptr, size, a->arg);
+}
+
+static inline void *sp_malloc(spa *a, size_t size) {
+	return a->alloc(NULL, size, a->arg);
+}
+
+static inline char *sp_strdup(spa *a, char *str) {
+	int sz = strlen(str) + 1;
+	char *s = a->alloc(NULL, sz, a->arg);
+	if (spunlikely(s == NULL))
+		return NULL;
+	memcpy(s, str, sz);
+	return s;
+}
+
+static inline void sp_free(spa *a, void *ptr) {
+	a->alloc(ptr, 0, a->arg);
+}
+
+#endif

data/vendor/sophia/db/cat.c

@@ -0,0 +1,195 @@
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#include <sp.h>
+
+static inline int sp_catensure(spcat *c) {
+	if ((c->count + 1) < c->top)
+		return 0;
+	c->top *= 2;
+	c->i = realloc(c->i, c->top * sizeof(sppage*));
+	if (c->i == NULL)
+		return -1;
+	return 0;
+}
+
+int sp_catinit(spcat *c, spa *a, int top, spcmpf cmp, void *cmparg) {
+	c->a = a;
+	c->cmp = cmp;
+	c->cmparg = cmparg;
+	c->count = 0;
+	c->top = top;
+	c->i = sp_malloc(a, sizeof(sppage*) * top);
+	if (spunlikely(c->i == NULL))
+		return -1;
+	return 0;
+}
+
+void sp_catfree(spcat *c) {
+	uint32_t p = 0;
+	while (p < c->count) {
+		sp_free(c->a, c->i[p]->min);
+		sp_free(c->a, c->i[p]->max);
+		sp_free(c->a, c->i[p]);
+		p++;
+	}
+	sp_free(c->a, c->i);
+}
+
+static inline int
+cmppage(spcat *c, sppage *p, sppage *v) {
+	int l = c->cmp(p->min->key,
+	               p->min->size,
+	               v->min->key,
+	               v->min->size, c->cmparg);
+	assert(l == c->cmp(p->max->key,
+	                   p->max->size,
+	                   v->max->key,
+	                   v->max->size, c->cmparg));
+	return l;
+}
+
+static inline sppage*
+sp_catsearch(spcat *c, sppage *v, uint32_t *index) {
+	int min = 0;
+	int max = c->count - 1;
+	while (max >= min) {
+		int mid = min + ((max - min) >> 1);
+		switch (cmppage(c, c->i[mid], v)) {
+		case -1: min = mid + 1;
+			continue;
+		case  1: max = mid - 1;
+			continue;
+		default:
+			*index = mid;
+			return c->i[mid];
+		}
+	}
+	*index = min;
+	return NULL;
+}
+
+int sp_catset(spcat *c, sppage *n, sppage **o)
+{
+	uint32_t i;
+	sppage *p = sp_catsearch(c, n, &i);
+	if (p) {
+		/* replace */
+		*o = c->i[i];
+		c->i[i] = p;
+		return 0;
+	}
+	/* insert */
+	int rc = sp_catensure(c);
+	if (spunlikely(rc == -1))
+		return -1;
+	/* split page index and insert new page */
+	memmove(&c->i[i + 1], &c->i[i], sizeof(sppage*) * (c->count - i));
+	c->i[i] = n;
+	c->count++;
+	*o = NULL;
+	return 0;
+}
+
+int sp_catdel(spcat *c, uint32_t idx)
+{
+	assert(idx < c->count);
+	if (splikely(idx != (uint32_t)(c->count-1)))
+		memmove(&c->i[idx], &c->i[idx + 1],
+		        sizeof(sppage*) * (c->count - idx - 1));
+	c->count--;
+	return 0;
+}
+
+static inline int
+cmpkey(spcat *c, sppage *p, void *rkey, int size)
+{
+	register int l =
+		c->cmp(p->min->key, p->min->size, rkey, size, c->cmparg);
+	register int r =
+		c->cmp(p->max->key, p->max->size, rkey, size, c->cmparg);
+	/* inside page range */
+	if (l <= 0 && r >= 0)
+		return 0;
+	/* key > page */
+	if (l == -1)
+		return -1;
+	/* key < page */
+	assert(r == 1);
+	return 1;
+}
+
+sppage*
+sp_catfind(spcat *c, char *rkey, int size, uint32_t *index)
+{
+	register int min = 0;
+	register int max = c->count - 1;
+	while (max >= min) {
+		register int mid = min + ((max - min) >> 1);
+		switch (cmpkey(c, c->i[mid], rkey, size)) {
+		case -1: min = mid + 1;
+			continue;
+		case  1: max = mid - 1;
+			continue;
+		default: *index = mid;
+			return c->i[mid];
+		}
+	}
+	*index = min;
+	return NULL;
+}
+
+sppage *sp_catroute(spcat *c, char *rkey, int size, uint32_t *idx)
+{
+	if (spunlikely(c->count == 1))
+		return c->i[0];
+	uint32_t i;
+	sppage *p = sp_catfind(c, rkey, size, &i);
+	if (splikely(p)) {
+		*idx = i;
+		return p;
+	}
+	if (spunlikely(i >= c->count))
+		i = c->count - 1;
+
+	if (i > 0 && c->cmp(c->i[i]->min->key, c->i[i]->min->size,
+	                    rkey,
+	                    size, c->cmparg) == 1) {
+		i = i - 1;
+	}
+	if (idx)
+		*idx = i;
+	return c->i[i];
+}
+
+int sp_catown(spcat *c, uint32_t idx, spv *v)
+{
+	register sppage *p = c->i[idx];
+	/* equal or equal min or equal max */
+	switch (cmpkey(c, p, v->key, v->size)) {
+	case  0:
+		return 1;
+	case -1: /* key > page */
+		/* key > max */
+		if (idx == c->count-1)
+			return 1;
+		break;
+	case  1: /* key < page */
+		/* key < min */
+		if (idx == 0)
+			return 1;
+		break;
+	}
+	/* key > page && key < page+1.min */
+	if (c->cmp(v->key, v->size,
+	           c->i[idx + 1]->min->key,
+	           c->i[idx + 1]->min->size, c->cmparg) == -1)
+		return 1;
+	return 0;
+}

data/vendor/sophia/db/cat.h

@@ -0,0 +1,32 @@
+#ifndef SP_CAT_H_
+#define SP_CAT_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+typedef struct spcat spcat;
+
+struct spcat {
+	spa *a;
+	sppage **i;
+	uint32_t count;
+	uint32_t top;
+	spcmpf cmp;
+	void *cmparg;
+};
+
+int sp_catinit(spcat*, spa*, int, spcmpf, void*);
+void sp_catfree(spcat*);
+int sp_catset(spcat*, sppage*, sppage**);
+int sp_catget(spcat*, uint64_t);
+int sp_catdel(spcat*, uint32_t);
+sppage *sp_catfind(spcat*, char*, int, uint32_t*);
+sppage *sp_catroute(spcat*, char*, int, uint32_t*);
+int sp_catown(spcat*, uint32_t, spv*);
+
+#endif

data/vendor/sophia/db/core.h

@@ -0,0 +1,129 @@
+#ifndef SP_CORE_H_
+#define SP_CORE_H_
+
+/*
+ * sophia database
+ * sphia.org
+ *
+ * Copyright (c) Dmitry Simonenko
+ * BSD License
+*/
+
+#define SP_VERSION_MAJOR 1
+#define SP_VERSION_MINOR 1
+
+typedef struct sp sp;
+typedef struct spenv spenv;
+
+enum spmagic {
+	SPMCUR  = 0x15481936L,
+	SPMENV  = 0x06154834L,
+	SPMDB   = 0x00fec0feL,
+	SPMNONE = 0L
+};
+
+typedef enum spmagic spmagic;
+
+struct spenv {
+	spmagic m;
+	spe e;
+	int inuse;
+	spallocf alloc;
+	void *allocarg;
+	spcmpf cmp;
+	void *cmparg;
+	uint32_t flags;
+	char *dir;
+	int merge;
+	uint32_t mergewm;
+	uint32_t page;
+	uint32_t dbnewsize;
+	float dbgrow;
+	int gc;
+	float gcfactor;
+};
+
+struct sp {
+	spmagic m;
+	spenv *e;
+	spa a;
+	sprep rep;
+	spi *i, i0, i1;
+	int iskip;          /* skip second index during read */
+	uint64_t psn;       /* page sequence number */
+	spcat s;
+	volatile int stop;
+	sptask merger;
+	sprefset refs;      /* pre allocated key buffer (page merge) */
+	int lockc;          /* incremental cursor lock */
+	spspinlock lockr;   /* repository lock */
+	spspinlock locks;   /* space lock */
+	spspinlock locki;   /* index lock */
+};
+
+int sp_rotate(sp*);
+
+static inline int sp_active(sp *s) {
+	return !s->stop;
+}
+
+static inline int
+sp_e(sp *s, int type, ...) {
+	va_list args;
+	va_start(args, type);
+	sp_ve(&s->e->e, type, args);
+	va_end(args);
+	return -1;
+}
+
+static inline int
+sp_ee(spenv *e, int type, ...) {
+	va_list args;
+	va_start(args, type);
+	sp_ve(&e->e, type, args);
+	va_end(args);
+	return -1;
+}
+
+static inline void
+sp_glock(sp *s) {
+	if (s->lockc > 0)
+		return;
+	sp_lock(&s->lockr);
+	sp_replockall(&s->rep);
+	sp_lock(&s->locki);
+	sp_lock(&s->locks);
+	s->lockc++;
+}
+
+static inline void
+sp_gunlock(sp *s) {
+	s->lockc--;
+	if (s->lockc > 0)
+		return;
+	sp_unlock(&s->locks);
+	sp_unlock(&s->locki);
+	sp_repunlockall(&s->rep);
+	sp_unlock(&s->lockr);
+}
+
+static inline void
+sp_iskipset(sp *s, int v) {
+	sp_lock(&s->locki);
+	s->iskip = v;
+	sp_unlock(&s->locki);
+}
+
+static inline spi*
+sp_ipair(sp *s) {
+	return (s->i == &s->i0 ? &s->i1 : &s->i0);
+}
+
+static inline spi*
+sp_iswap(sp *s) {
+	spi *old = s->i;
+	s->i = sp_ipair(s);
+	return old;
+}
+
+#endif