mirror of
https://github.com/urbit/ares.git
synced 2024-11-29 22:56:28 +03:00
337 lines
8.5 KiB
C
337 lines
8.5 KiB
C
#include "btree.h"
|
||
#include "btree.c"
|
||
|
||
#include <stdlib.h>
|
||
#include <stdio.h>
|
||
|
||
static void
|
||
_test_nodeinteg(BT_state *state, BT_findpath *path,
|
||
vaof_t lo, vaof_t hi, pgno_t pg)
|
||
{
|
||
size_t childidx = 0;
|
||
BT_page *parent = 0;
|
||
|
||
assert(SUCC(_bt_find(state, path, lo, hi)));
|
||
parent = path->path[path->depth];
|
||
childidx = path->idx[path->depth];
|
||
assert(parent->datk[childidx].fo == pg);
|
||
assert(parent->datk[childidx].va == lo);
|
||
assert(parent->datk[childidx+1].va == hi);
|
||
}
|
||
|
||
static size_t
|
||
_mlist_sizep(BT_mlistnode *head)
|
||
/* calculate the size of the mlist in pages */
|
||
{
|
||
size_t sz = 0;
|
||
while (head) {
|
||
size_t sz_p = addr2off(head->hi) - addr2off(head->lo);
|
||
sz += sz_p;
|
||
head = head->next;
|
||
}
|
||
return sz;
|
||
}
|
||
|
||
static size_t
|
||
_flist_sizep(BT_flistnode *head)
|
||
/* calculate the size of the flist in pages */
|
||
{
|
||
size_t sz = 0;
|
||
while (head) {
|
||
size_t sz_p = head->hi - head->lo;
|
||
sz += sz_p;
|
||
head = head->next;
|
||
}
|
||
return sz;
|
||
}
|
||
|
||
static BT_mlistnode *
|
||
_mlist_copy(BT_state *state)
|
||
{
|
||
BT_mlistnode *head = state->mlist;
|
||
BT_mlistnode *ret, *prev;
|
||
ret = prev = calloc(1, sizeof *ret);
|
||
memcpy(ret, head, sizeof *head);
|
||
ret->next = 0;
|
||
head = head->next;
|
||
while (head) {
|
||
BT_mlistnode *copy = calloc(1, sizeof *copy);
|
||
memcpy(copy, head, sizeof *head);
|
||
prev->next = copy;
|
||
prev = copy;
|
||
head = head->next;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static BT_nlistnode *
|
||
_nlist_copy(BT_state *state)
|
||
{
|
||
BT_nlistnode *head = state->nlist;
|
||
BT_nlistnode *ret, *prev;
|
||
ret = prev = calloc(1, sizeof *ret);
|
||
memcpy(ret, head, sizeof *head);
|
||
ret->next = 0;
|
||
head = head->next;
|
||
while (head) {
|
||
BT_nlistnode *copy = calloc(1, sizeof *copy);
|
||
memcpy(copy, head, sizeof *head);
|
||
prev->next = copy;
|
||
prev = copy;
|
||
head = head->next;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static BT_flistnode *
|
||
_flist_copy(BT_state *state)
|
||
{
|
||
BT_flistnode *head = state->flist;
|
||
BT_flistnode *ret, *prev;
|
||
ret = prev = calloc(1, sizeof *ret);
|
||
memcpy(ret, head, sizeof *head);
|
||
ret->next = 0;
|
||
head = head->next;
|
||
while (head) {
|
||
BT_flistnode *copy = calloc(1, sizeof *copy);
|
||
memcpy(copy, head, sizeof *head);
|
||
prev->next = copy;
|
||
prev = copy;
|
||
head = head->next;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
static int
|
||
_mlist_eq(BT_mlistnode *l, BT_mlistnode *r)
|
||
{
|
||
while (l && r) {
|
||
if (l->lo != r->lo)
|
||
bp(0);
|
||
if (l->hi != r->hi)
|
||
bp(0);
|
||
l = l->next; r = r->next;
|
||
}
|
||
if (l == 0 && r == 0)
|
||
return 1;
|
||
bp(0);
|
||
}
|
||
|
||
static int
|
||
_nlist_eq(BT_nlistnode *l, BT_nlistnode *r)
|
||
{
|
||
while (l && r) {
|
||
if (l->lo != r->lo)
|
||
bp(0);
|
||
if (l->hi != r->hi)
|
||
bp(0);
|
||
l = l->next; r = r->next;
|
||
}
|
||
if (l == 0 && r == 0)
|
||
return 1;
|
||
bp(0);
|
||
}
|
||
|
||
static int
|
||
_flist_eq(BT_flistnode *l, BT_flistnode *r)
|
||
{
|
||
while (l && r) {
|
||
if (l->lo != r->lo)
|
||
bp(0);
|
||
if (l->hi != r->hi)
|
||
bp(0);
|
||
l = l->next; r = r->next;
|
||
}
|
||
if (l == 0 && r == 0)
|
||
return 1;
|
||
bp(0);
|
||
}
|
||
|
||
int main(int argc, char *argv[])
|
||
{
|
||
DPRINTF("PMA Max Storage: %lld", ((uint64_t)UINT32_MAX * BT_PAGESIZE) - BLK_BASE_LEN_TOTAL);
|
||
DPUTS("PMA Tests");
|
||
|
||
BT_state *state1;
|
||
BT_findpath path = {0};
|
||
int rc = 0;
|
||
|
||
/* broken with recent changes. Maybe because we aren't mmapping the data
|
||
ranges (pure _bt_insert) */
|
||
#if 0
|
||
|
||
DPUTS("== test 1: insert");
|
||
|
||
bt_state_new(&state1);
|
||
if (mkdir("./pmatest1", 0774) == -1)
|
||
return errno;
|
||
assert(SUCC(bt_state_open(state1, "./pmatest1", 0, 0644)));
|
||
|
||
#define LOWEST_ADDR 0x2aaa80;
|
||
vaof_t lo = LOWEST_ADDR;
|
||
vaof_t hi = 0xDEADBEEF;
|
||
pgno_t pg = 1; /* dummy value */
|
||
for (size_t i = 0; i < BT_DAT_MAXKEYS * 4; ++i) {
|
||
_bt_insert(state1, lo, hi, pg);
|
||
_test_nodeinteg(state1, &path, lo, hi, pg);
|
||
lo++; pg++;
|
||
}
|
||
|
||
bt_state_close(state1);
|
||
#endif
|
||
|
||
|
||
DPUTS("== test 2: malloc");
|
||
BT_state *state2;
|
||
|
||
bt_state_new(&state2);
|
||
if (mkdir("./pmatest2", 0774) == -1)
|
||
return errno;
|
||
assert(SUCC(bt_state_open(state2, "./pmatest2", 0, 0644)));
|
||
|
||
void *t2a = bt_malloc(state2, 10);
|
||
bt_free(state2, t2a, (BT_page*)t2a + 10);
|
||
void *t2b = bt_malloc(state2, 10);
|
||
/* should have pulled the same pointer due to eager mlist coalescing */
|
||
assert(t2a == t2b);
|
||
ZERO(&path, sizeof path);
|
||
_bt_find(state2, &path, addr2off(t2b), addr2off((BT_page *)t2b + 10));
|
||
#define T2P1_PRNT0 (path.path[path.depth])
|
||
#define T2P1_CIDX0 (path.idx[path.depth])
|
||
#define T2P1_CIDX1 (path.idx[path.depth] + 1)
|
||
/* check length as represented in btree */
|
||
assert(T2P1_PRNT0->datk[T2P1_CIDX1].va
|
||
- T2P1_PRNT0->datk[T2P1_CIDX0].va
|
||
== 10);
|
||
bt_free(state2, t2b, (BT_page*)t2b + 10);
|
||
ZERO(&path, sizeof path);
|
||
_bt_find(state2, &path, addr2off(t2b), addr2off((BT_page *)t2b + 10));
|
||
/* fo should be zero (free) */
|
||
assert(path.path[path.depth]->datk[path.idx[path.depth]].fo == 0);
|
||
/* should invoke deletion coalescing - 10 page free range in btree */
|
||
void *t2c = bt_malloc(state2, 20);
|
||
|
||
bt_state_close(state2);
|
||
|
||
|
||
DPUTS("== test 3: ephemeral structure restoration");
|
||
BT_state *state3;
|
||
|
||
bt_state_new(&state3);
|
||
if (mkdir("./pmatest3", 0774) == -1)
|
||
return errno;
|
||
assert(SUCC(bt_state_open(state3, "./pmatest3", 0, 0644)));
|
||
|
||
typedef struct lohi_pair lohi_pair;
|
||
struct lohi_pair
|
||
{
|
||
BT_page *lo;
|
||
BT_page *hi;
|
||
};
|
||
|
||
#define ITERATIONS 1000
|
||
#define MAXALLOCPG 0xFF
|
||
lohi_pair allocs[ITERATIONS] = {0};
|
||
size_t alloc_sizp = 0;
|
||
size_t flist_sizp = _flist_sizep(state3->flist);
|
||
size_t mlist_sizp = _mlist_sizep(state3->mlist);
|
||
BT_meta *meta = state3->meta_pages[state3->which];
|
||
BT_page *root = _node_get(state3, meta->root);
|
||
size_t N;
|
||
for (size_t i = 0; i < ITERATIONS; i++) {
|
||
/* malloc a random number of pages <= 256 and store in the allocs array */
|
||
int pages = random();
|
||
pages &= MAXALLOCPG;
|
||
pages += 1;
|
||
allocs[i].lo = bt_malloc(state3, pages);
|
||
allocs[i].hi = allocs[i].lo + pages;
|
||
alloc_sizp += pages;
|
||
/* validate size changes to mlist and flist */
|
||
/* ;;: no longer a valid comparison since the flist may have grown */
|
||
/* assert(_flist_sizep(state3->flist) */
|
||
/* == (flist_sizp - alloc_sizp)); */
|
||
assert(_mlist_sizep(state3->mlist)
|
||
== (mlist_sizp - alloc_sizp));
|
||
N = _bt_numkeys(root);
|
||
assert(root->datk[N-2].fo == 0);
|
||
}
|
||
|
||
/* sync the state */
|
||
/* bt_sync(state3); */
|
||
|
||
/* TODO: close and reopen state. validate ephemeral structures */
|
||
|
||
flist_sizp = _flist_sizep(state3->flist);
|
||
mlist_sizp = _mlist_sizep(state3->mlist);
|
||
alloc_sizp = 0;
|
||
/* for (size_t i = 0; i < ITERATIONS / 2; i++) { */
|
||
/* /\* free half of the allocations *\/ */
|
||
/* bt_free(state3, allocs[i].lo, allocs[i].hi); */
|
||
/* alloc_sizp += allocs[i].hi - allocs[i].lo; */
|
||
/* /\* validate size changes to mlist *\/ */
|
||
/* assert(_mlist_sizep(state3->mlist) */
|
||
/* == (mlist_sizp + alloc_sizp)); */
|
||
/* } */
|
||
|
||
/* copy ephemeral structures */
|
||
BT_mlistnode *mlist_copy = _mlist_copy(state3);
|
||
BT_nlistnode *nlist_copy = _nlist_copy(state3);
|
||
BT_flistnode *flist_copy = _flist_copy(state3);
|
||
assert(_mlist_eq(mlist_copy, state3->mlist));
|
||
assert(_nlist_eq(nlist_copy, state3->nlist));
|
||
assert(_flist_eq(flist_copy, state3->flist));
|
||
|
||
meta = state3->meta_pages[state3->which];
|
||
BT_meta metacopy = {0};
|
||
memcpy(&metacopy, meta, sizeof metacopy);
|
||
|
||
bt_state_close(state3);
|
||
|
||
bt_state_new(&state3);
|
||
|
||
assert(SUCC(bt_state_open(state3, "./pmatest3", 0, 0644)));
|
||
|
||
/* compare for equality copies of ephemeral structures with restored ephemeral
|
||
structures */
|
||
meta = state3->meta_pages[state3->which];
|
||
/* ;;: fixme */
|
||
/* assert(meta->root == metacopy.root); */
|
||
/* assert(_mlist_eq(mlist_copy, state3->mlist)); */
|
||
/* assert(_nlist_eq(nlist_copy, state3->nlist)); */
|
||
/* assert(_flist_eq(flist_copy, state3->flist)); */
|
||
|
||
bt_state_close(state3);
|
||
|
||
|
||
DPUTS("== test 4: backing file extension");
|
||
BT_state *state4;
|
||
|
||
bt_state_new(&state4);
|
||
if (mkdir("./pmatest4", 0774) == -1)
|
||
return errno;
|
||
assert(SUCC(bt_state_open(state4, "./pmatest4", 0, 0644)));
|
||
|
||
#define PMA_INITIAL_SIZE_p PMA_GROW_SIZE_p
|
||
BYTE *t4a = bt_malloc(state4, PMA_GROW_SIZE_p * 2);
|
||
BYTE *t4b = t4a;
|
||
for (size_t i = 0; i < PMA_GROW_SIZE_b * 2; i++) {
|
||
*t4b++ = rand();
|
||
}
|
||
|
||
assert(state4->file_size_p == PMA_INITIAL_SIZE_p + PMA_GROW_SIZE_p * 2);
|
||
/* given the allocation pattern the head of the flist should also be the
|
||
tail. The hi page here should match the file size */
|
||
assert(state4->flist->hi == state4->file_size_p);
|
||
|
||
bt_state_close(state4);
|
||
|
||
bt_state_new(&state4);
|
||
|
||
assert(SUCC(bt_state_open(state4, "./pmatest4", 0, 0644)));
|
||
|
||
assert(state4->file_size_p == PMA_INITIAL_SIZE_p + PMA_GROW_SIZE_p * 2);
|
||
assert(state4->flist->hi == state4->file_size_p);
|
||
|
||
return 0;
|
||
}
|