radix.mx

一个内存数据库的源代码这是服务器端还有客户端

@(
#define integer1 int
#define integer2 int
#define integer4 int
#define integer8 int
#define integer16 int
#define integer32 int
#define integer64 int
#define integer128 int
#define integer256 int
@)

#ifdef HAVE_XMMINTRIN_H 
/* constants for use with _mm_prefetch */
#include <xmmintrin.h>
#endif

/* math.h files do not have M_PI/M_E defined */
#ifndef M_PI
# define M_PI		3.14159265358979323846	/* pi */
#endif
#ifndef M_E
# define M_E		2.7182818284590452354	/* e */
#endif

#define int_HUSSLE(x)	(((x)>>7)^((x)>>13)^((x)>>21)^(x))

@+ Experimentation Gimmicks
@- Data Generation
@c

int
M4_RDX_BATuniform(BAT **bn, oid *base, int *size, int *domain)
{
	size_t n = (size_t) * size, i, r;
	BAT *b = NULL;
	char *firstbun;
	int bunsize;		/* initialized in BATloopFast */
	oid bs = *base;
	int j = 0;
	BUN p, q;

	if (*size < 0) {
		GDKerror("BATuniform: size must not be negative");
		return GDK_FAIL;
	}

	b = BATnew(TYPE_oid, TYPE_int, n);
	if (b == NULL)
		return GDK_FAIL;
	if (n == 0) {
		b->tsorted = GDK_SORTED;
		b->hsorted = GDK_SORTED;
		b->hdense = TRUE;
		BATseqbase(b, *base);
		BATkey(b, TRUE);
		BATkey(BATmirror(b), TRUE);
		*bn = b;
		return GDK_SUCCEED;
	}

	firstbun = (char *) BUNfirst(b);
	/* preset b->batBuns->free to make BATloopFast work */
	b->batBuns->free = n * BUNsize(b);
	BATsetcount(b, n);
	/* create BUNs with uniform distribution */
	BATloopFast(b, p, q, bunsize) {
		*(oid *) BUNhloc(b, p) = bs ++;

		*(int *) BUNtloc(b, p) = j;
		if (++j >= *domain)
			j = 0;
	}
	/* mix BUNs randomly */
	for (r = i = 0; i < n; i++) {
		size_t idx = i + ((r += rand()) % (n - i));
		int val;

		p = (BUN) (firstbun + i * bunsize);	/* fast version of BUNptr */
		q = (BUN) (firstbun + idx * bunsize);
		val = *(int *) BUNtloc(b, p);
		*(int *) BUNtloc(b, p) = *(int *) BUNtloc(b, q);
		*(int *) BUNtloc(b, q) = val;
	}
	b->tsorted = FALSE;
	b->hdense = TRUE;
	BATseqbase(b, *base);
	BATkey(b, TRUE);
	*bn = b;
	return GDK_SUCCEED;
}

int
M4_RDX_BATuniform_b(BAT **bn, int *size, int *domain)
{
	oid base = 0;
	return M4_RDX_BATuniform(bn, &base, size, domain);
}

int
M4_RDX_BATuniform_bd(BAT **bn, int *size)
{
	oid base = 0;
	return M4_RDX_BATuniform(bn, &base, size, size);
}

int
M4_RDX_BATnormal(BAT **bn, oid *base, int *size, int *domain, int *stddev, int *mean)
{
	size_t n = (size_t) * size, i;
	unsigned int r = (unsigned int) n;
	size_t d = (size_t) * domain;
	BAT *b = NULL;
	char *firstbun;
	int bunsize;
	BUN p, q;
	int m = *mean, s = *stddev;
	oid bs = *base;
	int *itab;
	flt *ftab, tot = 0.0;

	if (*size < 0) {
		GDKerror("BATnormal: size must not be negative");
		return GDK_FAIL;
	}

        b = BATnew(TYPE_oid, TYPE_int, n);
	if (b == NULL)
		return GDK_FAIL;
	if (n == 0) {
		b->tsorted = GDK_SORTED;
		b->hsorted = GDK_SORTED;
		b->hdense = TRUE;
		BATseqbase(b, *base);
		BATkey(b, TRUE);
		BATkey(BATmirror(b), TRUE);
		*bn = b;
		return GDK_SUCCEED;
	}

	firstbun = (char *) BUNfirst(b);
	itab = (int *) GDKmalloc(d * sizeof(int));
	ftab = (flt *) itab;

	/* assert(0 <= *mean && *mean < *size); */

	/* created inverted table */
	for (i = 0; i < d; i++) {
		dbl tmp = (dbl) ((i - m) * (i - m));

		tmp = pow(M_E, -tmp / (2 * s * s)) / sqrt(2 * M_PI * s * s);
		ftab[i] = (flt) tmp;
		tot += ftab[i];
	}
	for (tot = (flt) (1.0 / tot), i = 0; i < d; i++) {
		itab[i] = (int) ((flt) n * ftab[i] * tot);
		r -= itab[i];
	}
	itab[m] += r;

	/* preset b->batBuns->free to make BATloopFast work */
	b->batBuns->free = n * BUNsize(b);
	BATsetcount(b, n);
	/* create BUNs with normal distribution */
	BATloopFast(b, p, q, bunsize) {
		*(oid *) BUNhloc(b, p) = bs ++;

		while (itab[r] == 0)
			r++;
		itab[r]--;
		*(int *) BUNtloc(b, p) = (int) r;
	}
	GDKfree(itab);

	/* mix BUNs randomly */
	for (r = 0, i = 0; i < n; i++) {
		size_t idx = i + ((r += rand()) % (n - i));
		int val;

		p = (BUN) (firstbun + i * bunsize);	/* fast version of BUNptr */
		q = (BUN) (firstbun + idx * bunsize);
		val = *(int *) BUNtloc(b, p);
		*(int *) BUNtloc(b, p) = *(int *) BUNtloc(b, q);
		*(int *) BUNtloc(b, q) = val;
	}
	b->tsorted = FALSE;
	b->hdense = TRUE;
	BATseqbase(b, *base);
	BATkey(b, TRUE);
	*bn = b;
	return GDK_SUCCEED;
}

int
M4_RDX_BATnormal_b(BAT **bn, int *size, int *domain, int *stddev, int *mean)
{
	oid base = 0;
	return M4_RDX_BATnormal(bn, &base, size, domain, stddev, mean);
}

int
M4_RDX_BATnormal_m(BAT **bn, oid *base, int *size, int *domain, int *stddev)
{
	int mean = *domain / 2;
	return M4_RDX_BATnormal(bn, base, size, domain, stddev, &mean);
}

int
M4_RDX_BATnormal_bm(BAT **bn, int *size, int *domain, int *stddev)
{
	oid base = 0;
	int mean = *domain / 2;
	return M4_RDX_BATnormal(bn, &base, size, domain, stddev, &mean);
}

int
M4_RDX_BATnormal_vm(BAT **bn, oid *base, int *size, int *domain)
{
	int stddev = *domain / 10;
	int mean = *domain / 2;
	return M4_RDX_BATnormal(bn, base, size, domain, &stddev, &mean);
}

int
M4_RDX_BATnormal_bvm(BAT **bn, int *size, int *domain)
{
	oid base = 0;
	int stddev = *domain / 10;
	int mean = *domain / 2;
	return M4_RDX_BATnormal(bn, &base, size, domain, &stddev, &mean);
}

int
M4_RDX_BATnormal_dvm(BAT **bn, oid *base, int *size)
{
	int domain = *size;
	int stddev = domain / 10;
	int mean = domain / 2;
	return M4_RDX_BATnormal(bn, base, size, &domain, &stddev, &mean);
}

int
M4_RDX_BATnormal_bdvm(BAT **bn, int *size)
{
	oid base = 0;
	int domain = *size;
	int stddev = domain / 10;
	int mean = domain / 2;
	return M4_RDX_BATnormal(bn, &base, size, &domain, &stddev, &mean);
}


@(
 @- data types for relational simulation

 @= integerdef
 @:integerdef_extern(@1)@
 @:integerdef_static(@1)@
 @
 @= integerdef_extern
#define integer@1 int
int  integer@1ToStr(str* dst, int* len, int* src) { return intToStr(dst,len,src); }
int  integer@1FromStr(str src, int* len, int** dst) { return intFromStr(src,len,dst); }
int  integer@1Cmp(int* l, int* r) { return *l - *r; }
int* integer@1Null(void) { integer_nil[0] = int_nil; return integer_nil; }
hash_t integer@1Hash(int*i) { return int_HUSSLE(*i); }
 @
 @= integerdef_static
static size_t
integer@1Copy(void *dst, void *src, size_t size)
{
	(void) size;
	*(int*) dst = *(int*) src;
	return sizeof(int);
}
static
int  integer@1Dummy(int i, int p) { S256; return i; } /* create some distance in the binary between fcns */
 @
 @c
#define S004 i=(i&255)*p; i=(i&255)*p; i=(i&255)*p; i=(i&255)*p;
#define S016 S004 S004 S004 S004
#define S256 S016 S016 S016 S016

int integer_nil[256];

 @:integerdef(1)@
 @:integerdef(2)@
 @:integerdef(4)@
 @:integerdef(8)@
 @:integerdef(16)@
 @:integerdef(32)@
 @:integerdef(64)@
 @:integerdef(128)@
/* otherwise, icc (correctly) complains about
 * integer256Copy() & integer256Dummy()
 * being "declared but never referenced"   */
 @:integerdef_extern(256)@

typedef struct {
	size_t(*cpy) (void *dst, void *src, size_t size);
	int (*fcn) (int i, int p);
	size_t size;
	int tpe;
} atom_t;

atom_t atomtbl[8] = {		/* a simulated ADT lookup table */
	{integer1Copy, integer1Dummy, sizeof(int), 0,},
	{integer2Co