void
BbTest7(void)
{
enum { NUM_RECS = 20 };
VAR_LUMP(v, MAX_DATA);
Key key = {{0}};
Bb t;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
RandLump(v);
BbPut(&t, RandKey().s, v);
}
BbDump(__FUNCTION__, &t);
for (;;) {
bool done;
BbNext(&t, key.s, key.s, &done);
if (done) {
break;
}
BbDelete(&t, key.s);
}
BbDelete(&t, key.s);
BbDump("Should be empty", &t);
BbReport(__FUNCTION__, BbDoAudit(&t));
if (0) aver(t.root == NULL);
BbFree(&t);
}
void LlInitBbInit(void)
{
BbInit();
BbBleInit();
#ifdef INIT_CENTRAL
BbBleScanMasterInit();
BbBleConnMasterInit();
#else
#ifdef INIT_OBSERVER
BbBleScanMasterInit();
#endif
#endif
#ifdef INIT_PERIPHERAL
BbBleAdvSlaveInit();
BbBleConnSlaveInit();
#else
#ifdef INIT_BROADCASTER
BbBleAdvSlaveInit();
#endif
#endif
BbBleTestInit();
}
void
BbTest16(void)
{
enum { NUM_KEYS = ONE_MILLION };
static Key key[NUM_KEYS];
VAR_LUMP(v, MAX_DATA);
Bb t;
Key a;
bool found;
u64 start, dt;
u64 i;
printf("%s\n", __FUNCTION__);
RandLump(v);
init_twister(17);
BbInit(&t, KEY_LEN);
for (i = 0; i < NUM_KEYS; i++) {
a = RandKey();
key[i] = a;
BbPut(&t, a.s, v);
}
start = nsecs();
for (i = 0; i < NUM_KEYS; i++) {
a = key[i];
BbGet(&t, a.s, &found);
if (!found) fatal("didn't find %s", a.s);
}
dt = nsecs() - start;
printf("%llu nsecs %g nsecs/get op\n", dt, (double)dt/(double)i);
BbFree(&t);
}
void
BbTest14(void)
{
enum { NUM_RECS = 200, NUM_ITER = 100 * ONE_THOUSAND };
VAR_LUMP(v, MAX_DATA);
Bb *t = emalloc(sizeof(*t) * NUM_ITER);
u64 start, dt;
u64 i, j;
printf("%s\n", __FUNCTION__);
init_twister(17);
RandLump(v);
start = nsecs();
for (j = 0; j < NUM_ITER; j++) {
BbInit(&t[j], KEY_LEN);
for (i = 0; i < NUM_RECS; i++) {
BbPut(&t[j], RandKey().s, v);
}
}
dt = nsecs() - start;
printf("%llu nsecs %g nsecs/op\n", dt, (double)dt/(double)(i * j));
BbReport(__FUNCTION__, BbDoAudit(&t[0]));
for (j = 0; j < NUM_ITER; j++) {
BbDoAudit(&t[j]);
BbFree(&t[j]);
}
}
void
BbTest4(void)
{
enum { NUM_RECS = 20 };
VAR_LUMP(v, MAX_DATA);
Lump a;
Bb t;
bool found;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
IntLump(v, i);
BbPut(&t, RandKey().s, v);
}
init_twister(17);
for (u64 i = 0; i < NUM_RECS; i++) {
IntLump(v, i);
a = BbGet(&t, RandKey().s, &found);
if (!found) {
fatal("didn't find %llu", i);
}
aver(memcmp(a.p, v.p, v.len) == 0);
}
BbDump(__FUNCTION__, &t);
BbFree(&t);
}
void
BbTest6(void)
{
enum { NUM_RECS = 2000, NUM_TRIALS = ONE_MILLION };
Bb t;
VAR_LUMP(v, MAX_DATA);
Key a[NUM_RECS];
u64 n = 0;
u64 puts = 0;
u64 deletes = 0;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
for (u64 j = 0; j < NUM_TRIALS; j++) {
Key key;
bool found;
if (Prob(((NUM_RECS - n) * 100) / NUM_RECS)) {
aver(n < NUM_RECS);
key = IntKey(twister_urand(10000));
BbGet(&t, key.s, &found);
if (!found) {
a[n++] = key;
RandLump(v);
BbPut(&t, key.s, v);
++puts;
}
if (0 || Prob(2)) Audit("Put", &t, a, n, j);
} else {
aver(0 < n);
u64 i = twister_urand(n);
key = a[i];
BbGet(&t, key.s, &found);
if (!found) {
BbDump("not found", &t);
fatal("didn't find %s %llu %llu", key.s, puts, deletes);
}
BbDelete(&t, key.s);
BbGet(&t, key.s, &found);
if (found) {
BbDump("found", &t);
fatal("found %llu", key);
}
a[i] = a[--n];
++deletes;
if (0 || Prob(2)) Audit("Delete", &t, a, n, j);
}
}
BbDoAudit(&t);
printf("\tputs=%llu deletes=%llu\n", puts, deletes);
BbReport(__FUNCTION__, BbDoAudit(&t));
BbDump(__FUNCTION__, &t);
BbFree(&t);
}
void
BbTest3(void)
{
enum { NUM_RECS = 200 };
Key key = {{0}};
Key next;
VAR_LUMP(v, MAX_DATA);
BB_ITER(iter, sizeof(Key));
Lump a;
Bb t;
bool found;
bool done;
printf("%s\n", __FUNCTION__);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
IntLump(v, i);
BbPut(&t, IntKey(i).s, v);
}
for (u64 i = 0; i < NUM_RECS; i++) {
IntLump(v, i);
a = BbGet(&t, IntKey(i).s, &found);
if (!found) {
fatal("didn't find %llu", i);
}
aver(memcmp(a.p, v.p, v.len) == 0);
}
for (u64 i = 0;; i++) {
a = BbNext(&t, key.s, next.s, &done);
if (done) {
if (i != NUM_RECS) fatal("Didn't find all the keys %llu %u", i, NUM_RECS);
break;
}
if (memcmp(next.s, key.s, sizeof(next.s)) <= 0) {
fatal("Keys not monotonically increasing %s %s", key.s, next.s);
}
key = next;
}
zero(key);
BbIterInit(iter, &t);
for (u64 i = 0;; i++) {
found = BbIterNext(iter);
if (!found) {
if (i != NUM_RECS) fatal("Didn't find all the keys %llu %u", i, NUM_RECS);
break;
}
if (memcmp(iter->key, key.s, sizeof(key.s)) <= 0) {
fatal("Keys not monotonically increasing %s %s", key.s, iter->key);
}
key = *(Key *)iter->key;
}
BbDump(__FUNCTION__, &t);
BbFree(&t);
}
void
BbTest17(void)
{
enum { NUM_KEYS = ONE_MILLION };
static Key key[NUM_KEYS];
VAR_LUMP(v, MAX_DATA);
Bb t;
BB_ITER(iter, sizeof(Key));
bool found;
u64 start, dt;
u64 i;
printf("%s\n", __FUNCTION__);
RandLump(v);
init_twister(17);
BbInit(&t, KEY_LEN);
for (i = 0; i < NUM_KEYS; i++) {
key[i] = RandKey();
}
start = nsecs();
for (i = 0; i < NUM_KEYS; i++) {
BbPut(&t, key[i].s, v);
}
dt = nsecs() - start;
printf("BbPut: %llu nsecs %g nsecs/put op\n", dt, (double)dt/(double)i);
start = nsecs();
for (i = 0; i < NUM_KEYS; i++) {
BbGet(&t, key[i].s, &found);
if (!found) fatal("didn't find %s", key[i].s);
}
dt = nsecs() - start;
printf("BbGet: %llu nsecs %g nsecs/get op\n", dt, (double)dt/(double)i);
//BbIter *iter = BbIterNew(&t);
BbIterInit(iter, &t);
start = nsecs();
for (i = 0; i < NUM_KEYS; i++) {
if (!BbIterNext(iter)) fatal("didn't find %s", iter->key);
}
dt = nsecs() - start;
//BbIterFree(iter);
printf("BbIter: %llu nsecs %g nsecs/get op\n", dt, (double)dt/(double)i);
start = nsecs();
for (i = 0; i < NUM_KEYS; i++) {
BbDelete(&t, key[i].s);
}
dt = nsecs() - start;
printf("BbDelete: %llu nsecs %g nsecs/delete op\n", dt, (double)dt/(double)i);
BbFree(&t);
}
void
BbTest1(void)
{
enum { NUM_RECS = 100 };
VAR_LUMP(v, MAX_DATA);
Bb t;
printf("%s\n", __FUNCTION__);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
if (1) IntLump(v, i);
else RandLump(v);
BbPut(&t, IntKey(i+1).s, v);
}
BbDump(__FUNCTION__, &t);
}
void
BbTest2(void)
{
enum { NUM_RECS = 100 };
VAR_LUMP(v, MAX_DATA);
Bb t;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
if (1) IntLump(v, i);
else IntLump(v, twister_urand(1000));
if (0) BbPut(&t, RandKey().s, v);
else BbPut(&t, IntKey(twister_urand(1000)).s, v);
}
BbDump(__FUNCTION__, &t);
BbFree(&t);
}
void
BbTest13(void)
{
enum { NUM_RECS = 10 * ONE_MILLION / 10 };
VAR_LUMP(v, MAX_DATA);
Bb t;
u64 start, dt;
u64 i;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
RandLump(v);
start = nsecs();
for (i = 0; i < NUM_RECS; i++) {
BbPut(&t, RandKey().s, v);
}
dt = nsecs() - start;
printf("%llu nsecs %g nsecs/op\n", dt, (double)dt/(double)i);
BbReport(__FUNCTION__, BbDoAudit(&t));
BbFree(&t);
}
void
BbTest5(void)
{
enum { NUM_RECS = 20 };
VAR_LUMP(v, MAX_DATA);
Key key = {{0}};
Lump a, b;
Bb t;
bool found;
printf("%s\n", __FUNCTION__);
init_twister(17);
BbInit(&t, KEY_LEN);
for (u64 i = 0; i < NUM_RECS; i++) {
IntLump(v, i);
BbPut(&t, RandKey().s, v);
}
BbDump(__FUNCTION__, &t);
for (u64 i = 0;;i++) {
bool done;
a = BbNext(&t, key.s, key.s, &done);
if (done) {
if (i != NUM_RECS) fatal("Didn't find all the keys %llu %u", i, NUM_RECS);
break;
}
b = BbGet(&t, key.s, &found);
if (!found) {
fatal("didn't find %llu", key);
}
aver(a.len == b.len);
aver(strcmp(a.p, b.p) == 0);
}
BbDump(__FUNCTION__, &t);
BbFree(&t);
}
void
BbTest15(void)
{
enum { NUM_RECS = 200, NUM_ITER = 10 * ONE_THOUSAND };
VAR_LUMP(v, MAX_DATA);
Bb *t = emalloc(sizeof(*t) * NUM_ITER);
bool found;
u64 start, dt;
u64 i, j;
printf("%s\n", __FUNCTION__);
RandLump(v);
init_twister(17);
start = nsecs();
for (j = 0; j < NUM_ITER; j++) {
BbInit(&t[j], KEY_LEN);
for (i = 0; i < NUM_RECS; i++) {
BbPut(&t[j], RandKey().s, v);
}
}
dt = nsecs() - start;
printf("put %llu nsecs %g nsecs/op\n", dt, (double)dt/(double)(i * j));
init_twister(17);
start = nsecs();
for (j = 0; j < NUM_ITER; j++) {
for (i = 0; i < NUM_RECS; i++) {
BbGet(&t[j], RandKey().s, &found);
if (!found) {
fatal("Didn't find key for iter %llu rec %llu", j, i);
}
}
}
dt = nsecs() - start;
printf("get %llu nsecs %g nsecs/op\n", dt, (double)dt/(double)(i * j));
start = nsecs();
for (j = 0; j < NUM_ITER; j++) {
for (i = 0; i < NUM_RECS; i++) {
Key key;
bool isEof;
BbNext(&t[j], RandKey().s, key.s, &isEof);
if (!found) {
fatal("Didn't find key for iter %llu rec %llu", j, i);
}
}
}
dt = nsecs() - start;
printf("next %llu nsecs %g nsecs/op\n", dt, (double)dt/(double)(i * j));
init_twister(17);
start = nsecs();
for (j = 0; j < NUM_ITER; j++) {
for (i = 0; i < NUM_RECS; i++) {
RandKey();
}
}
dt = nsecs() - start;
printf("overhead %llu nsecs %g nsecs/op\n", dt, (double)dt/(double)(i * j));
for (j = 0; j < NUM_ITER; j++) {
BbFree(&t[j]);
}
}
