Browse Source
#3185 merge from the tokudb.3185 branch to main refs[t:3185]
#3185 merge from the tokudb.3185 branch to main refs[t:3185]
git-svn-id: file:///svn/toku/tokudb@27723 c7de825b-a66e-492c-adef-691d508d4ae1pull/73/head
Rich Prohaska
13 years ago
committed by
Yoni Fogel
Yoni Fogel
19 changed files with 1205 additions and 118 deletions
-
11buildheader/db.h_4_1
-
11buildheader/db.h_4_3
-
11buildheader/db.h_4_4
-
11buildheader/db.h_4_5
-
11buildheader/db.h_4_6
-
5buildheader/make_db_h.c
-
9buildheader/tdb.h
-
9include/db.h
-
4newbrt/brt-internal.h
-
222newbrt/brt-verify.c
-
2newbrt/brt.c
-
1newbrt/brt.h
-
187newbrt/tests/verify-bad-pivots.c
-
119newbrt/tests/verify-dup-in-leaf.c
-
187newbrt/tests/verify-dup-pivots.c
-
191newbrt/tests/verify-misrouted-msgs.c
-
119newbrt/tests/verify-unsorted-leaf.c
-
187newbrt/tests/verify-unsorted-pivots.c
-
26src/ydb.c
@ -0,0 +1,187 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with bad pivots and check that brt->verify finds them |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int seq, int n, int *minkey, int *maxkey) { |
|||
for (int i = 0; i < n; i++) { |
|||
int k = htonl(seq + i); |
|||
int v = seq + i; |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
*minkey = htonl(seq); |
|||
*maxkey = htonl(seq + n - 1); |
|||
} |
|||
|
|||
static UU() void |
|||
insert_into_child_buffer(BRTNODE node, int childnum, int minkey, int maxkey) { |
|||
for (unsigned int val = htonl(minkey); val <= htonl(maxkey); val++) { |
|||
unsigned int key = htonl(val); |
|||
DBT thekey; toku_fill_dbt(&thekey, &key, sizeof key); |
|||
DBT theval; toku_fill_dbt(&theval, &val, sizeof val); |
|||
toku_brt_append_to_child_buffer(node, childnum, BRT_INSERT, xids_get_root_xids(), &thekey, &theval); |
|||
} |
|||
} |
|||
|
|||
static BRTNODE |
|||
make_tree(BRT brt, int height, int fanout, int nperleaf, int *seq, int *minkey, int *maxkey) { |
|||
BRTNODE node; |
|||
if (height == 0) { |
|||
node = make_node(brt, 0); |
|||
populate_leaf(node, *seq, nperleaf, minkey, maxkey); |
|||
*seq += nperleaf; |
|||
} else { |
|||
node = make_node(brt, height); |
|||
int minkeys[fanout], maxkeys[fanout]; |
|||
for (int childnum = 0; childnum < fanout; childnum++) { |
|||
BRTNODE child = make_tree(brt, height-1, fanout, nperleaf, seq, &minkeys[childnum], &maxkeys[childnum]); |
|||
if (childnum == 0) |
|||
toku_brt_nonleaf_append_child(node, child, NULL, 0); |
|||
else { |
|||
int k = minkeys[childnum]; // use the min key of the right subtree, which creates a broken tree |
|||
struct kv_pair *pivotkey = kv_pair_malloc(&k, sizeof k, NULL, 0); |
|||
toku_brt_nonleaf_append_child(node, child, pivotkey, sizeof k); |
|||
} |
|||
int r = toku_unpin_brtnode(brt, child); |
|||
assert(r == 0); |
|||
} |
|||
*minkey = minkeys[0]; |
|||
*maxkey = maxkeys[0]; |
|||
for (int i = 1; i < fanout; i++) { |
|||
if (memcmp(minkey, &minkeys[i], sizeof minkeys[i]) > 0) |
|||
*minkey = minkeys[i]; |
|||
if (memcmp(maxkey, &maxkeys[i], sizeof maxkeys[i]) < 0) |
|||
*maxkey = maxkeys[i]; |
|||
} |
|||
} |
|||
return node; |
|||
} |
|||
|
|||
static UU() void |
|||
deleted_row(UU() DB *db, UU() DBT *key, UU() DBT *val) { |
|||
} |
|||
|
|||
static void |
|||
test_make_tree(int height, int fanout, int nperleaf, int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// make a tree |
|||
int seq = 0, minkey, maxkey; |
|||
BRTNODE newroot = make_tree(brt, height, fanout, nperleaf, &seq, &minkey, &maxkey); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int height = 1; |
|||
int fanout = 2; |
|||
int nperleaf = 8; |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--height") == 0 && i+1 < argc) { |
|||
height = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--fanout") == 0 && i+1 < argc) { |
|||
fanout = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--nperleaf") == 0 && i+1 < argc) { |
|||
nperleaf = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_make_tree(height, fanout, nperleaf, do_verify); |
|||
return 0; |
|||
} |
|||
@ -0,0 +1,119 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with a single leaf node containing duplicate keys |
|||
// check that brt verify finds them |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int k, int v) { |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
|
|||
static void |
|||
test_dup_in_leaf(int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
BRTNODE newroot = make_node(brt, 0); |
|||
populate_leaf(newroot, htonl(2), 1); |
|||
populate_leaf(newroot, htonl(2), 2); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_dup_in_leaf(do_verify); |
|||
return 0; |
|||
} |
|||
@ -0,0 +1,187 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with duplicate pivots and check that brt->verify finds them |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int seq, int n, int *minkey, int *maxkey) { |
|||
for (int i = 0; i < n; i++) { |
|||
int k = htonl(seq + i); |
|||
int v = seq + i; |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
*minkey = htonl(seq); |
|||
*maxkey = htonl(seq + n - 1); |
|||
} |
|||
|
|||
static UU() void |
|||
insert_into_child_buffer(BRTNODE node, int childnum, int minkey, int maxkey) { |
|||
for (unsigned int val = htonl(minkey); val <= htonl(maxkey); val++) { |
|||
unsigned int key = htonl(val); |
|||
DBT thekey; toku_fill_dbt(&thekey, &key, sizeof key); |
|||
DBT theval; toku_fill_dbt(&theval, &val, sizeof val); |
|||
toku_brt_append_to_child_buffer(node, childnum, BRT_INSERT, xids_get_root_xids(), &thekey, &theval); |
|||
} |
|||
} |
|||
|
|||
static BRTNODE |
|||
make_tree(BRT brt, int height, int fanout, int nperleaf, int *seq, int *minkey, int *maxkey) { |
|||
BRTNODE node; |
|||
if (height == 0) { |
|||
node = make_node(brt, 0); |
|||
populate_leaf(node, *seq, nperleaf, minkey, maxkey); |
|||
*seq += nperleaf; |
|||
} else { |
|||
node = make_node(brt, height); |
|||
int minkeys[fanout], maxkeys[fanout]; |
|||
for (int childnum = 0; childnum < fanout; childnum++) { |
|||
BRTNODE child = make_tree(brt, height-1, fanout, nperleaf, seq, &minkeys[childnum], &maxkeys[childnum]); |
|||
if (childnum == 0) |
|||
toku_brt_nonleaf_append_child(node, child, NULL, 0); |
|||
else { |
|||
int k = maxkeys[0]; // use duplicate pivots, should result in a broken tree |
|||
struct kv_pair *pivotkey = kv_pair_malloc(&k, sizeof k, NULL, 0); |
|||
toku_brt_nonleaf_append_child(node, child, pivotkey, sizeof k); |
|||
} |
|||
int r = toku_unpin_brtnode(brt, child); |
|||
assert(r == 0); |
|||
} |
|||
*minkey = minkeys[0]; |
|||
*maxkey = maxkeys[0]; |
|||
for (int i = 1; i < fanout; i++) { |
|||
if (memcmp(minkey, &minkeys[i], sizeof minkeys[i]) > 0) |
|||
*minkey = minkeys[i]; |
|||
if (memcmp(maxkey, &maxkeys[i], sizeof maxkeys[i]) < 0) |
|||
*maxkey = maxkeys[i]; |
|||
} |
|||
} |
|||
return node; |
|||
} |
|||
|
|||
static UU() void |
|||
deleted_row(UU() DB *db, UU() DBT *key, UU() DBT *val) { |
|||
} |
|||
|
|||
static void |
|||
test_make_tree(int height, int fanout, int nperleaf, int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// make a tree |
|||
int seq = 0, minkey, maxkey; |
|||
BRTNODE newroot = make_tree(brt, height, fanout, nperleaf, &seq, &minkey, &maxkey); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int height = 1; |
|||
int fanout = 3; |
|||
int nperleaf = 8; |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--height") == 0 && i+1 < argc) { |
|||
height = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--fanout") == 0 && i+1 < argc) { |
|||
fanout = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--nperleaf") == 0 && i+1 < argc) { |
|||
nperleaf = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_make_tree(height, fanout, nperleaf, do_verify); |
|||
return 0; |
|||
} |
|||
@ -0,0 +1,191 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with misrouted messages in the child buffers. |
|||
// check that brt verify finds them. |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int seq, int n, int *minkey, int *maxkey) { |
|||
for (int i = 0; i < n; i++) { |
|||
int k = htonl(seq + i); |
|||
int v = seq + i; |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
*minkey = htonl(seq); |
|||
*maxkey = htonl(seq + n - 1); |
|||
} |
|||
|
|||
static void |
|||
insert_into_child_buffer(BRTNODE node, int childnum, int minkey, int maxkey) { |
|||
int k = htonl(maxkey); |
|||
maxkey = htonl(k+1); |
|||
for (unsigned int val = htonl(minkey); val <= htonl(maxkey); val++) { |
|||
unsigned int key = htonl(val); |
|||
DBT thekey; toku_fill_dbt(&thekey, &key, sizeof key); |
|||
DBT theval; toku_fill_dbt(&theval, &val, sizeof val); |
|||
toku_brt_append_to_child_buffer(node, childnum, BRT_INSERT, xids_get_root_xids(), &thekey, &theval); |
|||
} |
|||
} |
|||
|
|||
static BRTNODE |
|||
make_tree(BRT brt, int height, int fanout, int nperleaf, int *seq, int *minkey, int *maxkey) { |
|||
BRTNODE node; |
|||
if (height == 0) { |
|||
node = make_node(brt, 0); |
|||
populate_leaf(node, *seq, nperleaf, minkey, maxkey); |
|||
*seq += nperleaf; |
|||
} else { |
|||
node = make_node(brt, height); |
|||
int minkeys[fanout], maxkeys[fanout]; |
|||
for (int childnum = 0; childnum < fanout; childnum++) { |
|||
BRTNODE child = make_tree(brt, height-1, fanout, nperleaf, seq, &minkeys[childnum], &maxkeys[childnum]); |
|||
if (childnum == 0) |
|||
toku_brt_nonleaf_append_child(node, child, NULL, 0); |
|||
else { |
|||
int k = maxkeys[childnum-1]; // use the max of the left tree |
|||
struct kv_pair *pivotkey = kv_pair_malloc(&k, sizeof k, NULL, 0); |
|||
toku_brt_nonleaf_append_child(node, child, pivotkey, sizeof k); |
|||
} |
|||
int r = toku_unpin_brtnode(brt, child); |
|||
assert(r == 0); |
|||
insert_into_child_buffer(node, childnum, minkeys[childnum], maxkeys[childnum]); |
|||
} |
|||
*minkey = minkeys[0]; |
|||
*maxkey = maxkeys[0]; |
|||
for (int i = 1; i < fanout; i++) { |
|||
if (memcmp(minkey, &minkeys[i], sizeof minkeys[i]) > 0) |
|||
*minkey = minkeys[i]; |
|||
if (memcmp(maxkey, &maxkeys[i], sizeof maxkeys[i]) < 0) |
|||
*maxkey = maxkeys[i]; |
|||
} |
|||
} |
|||
return node; |
|||
} |
|||
|
|||
static UU() void |
|||
deleted_row(UU() DB *db, UU() DBT *key, UU() DBT *val) { |
|||
} |
|||
|
|||
static void |
|||
test_make_tree(int height, int fanout, int nperleaf, int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// make a tree |
|||
int seq = 0, minkey, maxkey; |
|||
BRTNODE newroot = make_tree(brt, height, fanout, nperleaf, &seq, &minkey, &maxkey); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int height = 1; |
|||
int fanout = 2; |
|||
int nperleaf = 8; |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--height") == 0 && i+1 < argc) { |
|||
height = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--fanout") == 0 && i+1 < argc) { |
|||
fanout = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--nperleaf") == 0 && i+1 < argc) { |
|||
nperleaf = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_make_tree(height, fanout, nperleaf, do_verify); |
|||
return 0; |
|||
} |
|||
@ -0,0 +1,119 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with a single leaf node containing unsorted keys |
|||
// check that brt verify finds them |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int k, int v) { |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
|
|||
static void |
|||
test_dup_in_leaf(int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
BRTNODE newroot = make_node(brt, 0); |
|||
populate_leaf(newroot, htonl(2), 1); |
|||
populate_leaf(newroot, htonl(1), 2); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_dup_in_leaf(do_verify); |
|||
return 0; |
|||
} |
|||
@ -0,0 +1,187 @@ |
|||
/* -*- mode: C; c-basic-offset: 4 -*- */ |
|||
#ident "Copyright (c) 2011 Tokutek Inc. All rights reserved." |
|||
|
|||
// generate a tree with unsorted pivots and check that brt->verify finds them |
|||
|
|||
#include "includes.h" |
|||
#include "test.h" |
|||
|
|||
static BRTNODE |
|||
make_node(BRT brt, int height) { |
|||
BRTNODE node = NULL; |
|||
int r = toku_create_new_brtnode(brt, &node, height, 0); |
|||
assert(r == 0); |
|||
return node; |
|||
} |
|||
|
|||
static void |
|||
append_leaf(BRTNODE leafnode, void *key, size_t keylen, void *val, size_t vallen) { |
|||
assert(leafnode->height == 0); |
|||
|
|||
DBT thekey; toku_fill_dbt(&thekey, key, keylen); |
|||
DBT theval; toku_fill_dbt(&theval, val, vallen); |
|||
|
|||
// get an index that we can use to create a new leaf entry |
|||
uint32_t idx = toku_omt_size(leafnode->u.l.buffer); |
|||
|
|||
// apply an insert to the leaf node |
|||
BRT_MSG_S cmd = { BRT_INSERT, xids_get_root_xids(), .u.id = { &thekey, &theval } }; |
|||
int r = brt_leaf_apply_cmd_once(leafnode, &cmd, idx, NULL, NULL); |
|||
assert(r == 0); |
|||
|
|||
// dont forget to dirty the node |
|||
leafnode->dirty = 1; |
|||
} |
|||
|
|||
static void |
|||
populate_leaf(BRTNODE leafnode, int seq, int n, int *minkey, int *maxkey) { |
|||
for (int i = 0; i < n; i++) { |
|||
int k = htonl(seq + i); |
|||
int v = seq + i; |
|||
append_leaf(leafnode, &k, sizeof k, &v, sizeof v); |
|||
} |
|||
*minkey = htonl(seq); |
|||
*maxkey = htonl(seq + n - 1); |
|||
} |
|||
|
|||
static UU() void |
|||
insert_into_child_buffer(BRTNODE node, int childnum, int minkey, int maxkey) { |
|||
for (unsigned int val = htonl(minkey); val <= htonl(maxkey); val++) { |
|||
unsigned int key = htonl(val); |
|||
DBT thekey; toku_fill_dbt(&thekey, &key, sizeof key); |
|||
DBT theval; toku_fill_dbt(&theval, &val, sizeof val); |
|||
toku_brt_append_to_child_buffer(node, childnum, BRT_INSERT, xids_get_root_xids(), &thekey, &theval); |
|||
} |
|||
} |
|||
|
|||
static BRTNODE |
|||
make_tree(BRT brt, int height, int fanout, int nperleaf, int *seq, int *minkey, int *maxkey) { |
|||
BRTNODE node; |
|||
if (height == 0) { |
|||
node = make_node(brt, 0); |
|||
populate_leaf(node, *seq, nperleaf, minkey, maxkey); |
|||
*seq += nperleaf; |
|||
} else { |
|||
node = make_node(brt, height); |
|||
int minkeys[fanout], maxkeys[fanout]; |
|||
for (int childnum = 0; childnum < fanout; childnum++) { |
|||
BRTNODE child = make_tree(brt, height-1, fanout, nperleaf, seq, &minkeys[childnum], &maxkeys[childnum]); |
|||
if (childnum == 0) |
|||
toku_brt_nonleaf_append_child(node, child, NULL, 0); |
|||
else { |
|||
int k = minkeys[fanout - childnum - 1]; // use unsorted pivots |
|||
struct kv_pair *pivotkey = kv_pair_malloc(&k, sizeof k, NULL, 0); |
|||
toku_brt_nonleaf_append_child(node, child, pivotkey, sizeof k); |
|||
} |
|||
int r = toku_unpin_brtnode(brt, child); |
|||
assert(r == 0); |
|||
} |
|||
*minkey = minkeys[0]; |
|||
*maxkey = maxkeys[0]; |
|||
for (int i = 1; i < fanout; i++) { |
|||
if (memcmp(minkey, &minkeys[i], sizeof minkeys[i]) > 0) |
|||
*minkey = minkeys[i]; |
|||
if (memcmp(maxkey, &maxkeys[i], sizeof maxkeys[i]) < 0) |
|||
*maxkey = maxkeys[i]; |
|||
} |
|||
} |
|||
return node; |
|||
} |
|||
|
|||
static UU() void |
|||
deleted_row(UU() DB *db, UU() DBT *key, UU() DBT *val) { |
|||
} |
|||
|
|||
static void |
|||
test_make_tree(int height, int fanout, int nperleaf, int do_verify) { |
|||
int r; |
|||
|
|||
// cleanup |
|||
char fname[]= __FILE__ ".brt"; |
|||
r = unlink(fname); |
|||
assert(r == 0 || (r == -1 && errno == ENOENT)); |
|||
|
|||
// create a cachetable |
|||
CACHETABLE ct = NULL; |
|||
r = toku_brt_create_cachetable(&ct, 0, ZERO_LSN, NULL_LOGGER); |
|||
assert(r == 0); |
|||
|
|||
// create the brt |
|||
TOKUTXN null_txn = NULL; |
|||
DB *null_db = NULL; |
|||
BRT brt = NULL; |
|||
r = toku_open_brt(fname, 1, &brt, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); |
|||
assert(r == 0); |
|||
|
|||
// make a tree |
|||
int seq = 0, minkey, maxkey; |
|||
BRTNODE newroot = make_tree(brt, height, fanout, nperleaf, &seq, &minkey, &maxkey); |
|||
|
|||
// discard the old root block |
|||
u_int32_t fullhash = 0; |
|||
CACHEKEY *rootp; |
|||
rootp = toku_calculate_root_offset_pointer(brt, &fullhash); |
|||
|
|||
// set the new root to point to the new tree |
|||
*rootp = newroot->thisnodename; |
|||
|
|||
// unpin the new root |
|||
r = toku_unpin_brtnode(brt, newroot); |
|||
assert(r == 0); |
|||
|
|||
if (do_verify) { |
|||
r = toku_verify_brt(brt); |
|||
assert(r != 0); |
|||
} |
|||
|
|||
// flush to the file system |
|||
r = toku_close_brt(brt, 0); |
|||
assert(r == 0); |
|||
|
|||
// shutdown the cachetable |
|||
r = toku_cachetable_close(&ct); |
|||
assert(r == 0); |
|||
} |
|||
|
|||
static int |
|||
usage(void) { |
|||
return 1; |
|||
} |
|||
|
|||
int |
|||
test_main (int argc , const char *argv[]) { |
|||
int height = 1; |
|||
int fanout = 3; |
|||
int nperleaf = 8; |
|||
int do_verify = 1; |
|||
for (int i = 1; i < argc; i++) { |
|||
const char *arg = argv[i]; |
|||
if (strcmp(arg, "-v") == 0) { |
|||
verbose++; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "-q") == 0) { |
|||
verbose = 0; |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--height") == 0 && i+1 < argc) { |
|||
height = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--fanout") == 0 && i+1 < argc) { |
|||
fanout = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--nperleaf") == 0 && i+1 < argc) { |
|||
nperleaf = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
if (strcmp(arg, "--verify") == 0 && i+1 < argc) { |
|||
do_verify = atoi(argv[++i]); |
|||
continue; |
|||
} |
|||
return usage(); |
|||
} |
|||
test_make_tree(height, fanout, nperleaf, do_verify); |
|||
return 0; |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue